luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-14 05:16:18 +01:00
Code Issues Packages Projects Releases Wiki Activity
e2639ce56e
glib/gio/tests/error.c
Marco Trevisan (Treviño) b64fd312da gerror: Add an utility function to get the GIO Error from GFileError 
When GIO functions are using GLib file utils functions we expect to
return a GIO Error, so provide a way to map such error values.
2022-06-22 20:07:25 +02:00

857 lines
24 KiB
C
Raw Blame History

/* Unit tests for gioerror
* GIO - GLib Input, Output and Streaming Library
*
* Copyright (C) 2022 Marco Trevisan
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
* Author: Marco Trevisan <marco.trevisan@canonical.com>
*/
#include "config.h"
#include <errno.h>
#include <gio/gio.h>
#ifdef G_OS_WIN32
#include <winsock2.h>
#endif
/* We are testing some deprecated APIs here */
#ifndef GLIB_DISABLE_DEPRECATION_WARNINGS
#define GLIB_DISABLE_DEPRECATION_WARNINGS
#endif
static void
test_error_from_errno (void)
{
g_assert_cmpint (g_io_error_from_errno (-1), ==, G_IO_ERROR_FAILED);
#ifdef EEXIST
g_assert_cmpint (g_io_error_from_errno (EEXIST), ==,
G_IO_ERROR_EXISTS);
#endif
#ifdef EISDIR
g_assert_cmpint (g_io_error_from_errno (EISDIR), ==,
G_IO_ERROR_IS_DIRECTORY);
#endif
#ifdef EACCES
g_assert_cmpint (g_io_error_from_errno (EACCES), ==,
G_IO_ERROR_PERMISSION_DENIED);
#endif
#ifdef ENAMETOOLONG
g_assert_cmpint (g_io_error_from_errno (ENAMETOOLONG), ==,
G_IO_ERROR_FILENAME_TOO_LONG);
#endif
#ifdef ENOENT
g_assert_cmpint (g_io_error_from_errno (ENOENT), ==,
G_IO_ERROR_NOT_FOUND);
#endif
#ifdef ENOTDIR
g_assert_cmpint (g_io_error_from_errno (ENOTDIR), ==,
G_IO_ERROR_NOT_DIRECTORY);
#endif
#ifdef ENXIO
g_assert_cmpint (g_io_error_from_errno (ENXIO), ==,
G_IO_ERROR_NOT_REGULAR_FILE);
#endif
#ifdef EROFS
g_assert_cmpint (g_io_error_from_errno (EROFS), ==,
G_IO_ERROR_READ_ONLY);
#endif
#ifdef ELOOP
g_assert_cmpint (g_io_error_from_errno (ELOOP), ==,
G_IO_ERROR_TOO_MANY_LINKS);
#endif
#ifdef EMLINK
g_assert_cmpint (g_io_error_from_errno (EMLINK), ==,
G_IO_ERROR_TOO_MANY_LINKS);
#endif
#ifdef ENOSPC
g_assert_cmpint (g_io_error_from_errno (ENOSPC), ==,
G_IO_ERROR_NO_SPACE);
#endif
#ifdef ENOMEM
g_assert_cmpint (g_io_error_from_errno (ENOMEM), ==,
G_IO_ERROR_NO_SPACE);
#endif
#ifdef EINVAL
g_assert_cmpint (g_io_error_from_errno (EINVAL), ==,
G_IO_ERROR_INVALID_ARGUMENT);
#endif
#ifdef EPERM
g_assert_cmpint (g_io_error_from_errno (EPERM), ==,
G_IO_ERROR_PERMISSION_DENIED);
#endif
#ifdef ECANCELED
g_assert_cmpint (g_io_error_from_errno (ECANCELED), ==,
G_IO_ERROR_CANCELLED);
#endif
#ifdef ENOTEMPTY
g_assert_cmpint (g_io_error_from_errno (ENOTEMPTY), ==,
G_IO_ERROR_NOT_EMPTY);
#endif
#ifdef ENOTSUP
g_assert_cmpint (g_io_error_from_errno (ENOTSUP), ==,
G_IO_ERROR_NOT_SUPPORTED);
#endif
#ifdef EOPNOTSUPP
g_assert_cmpint (g_io_error_from_errno (EOPNOTSUPP), ==,
G_IO_ERROR_NOT_SUPPORTED);
#endif
#ifdef EPROTONOSUPPORT
g_assert_cmpint (g_io_error_from_errno (EPROTONOSUPPORT), ==,
G_IO_ERROR_NOT_SUPPORTED);
#endif
#ifdef ESOCKTNOSUPPORT
g_assert_cmpint (g_io_error_from_errno (ESOCKTNOSUPPORT), ==,
G_IO_ERROR_NOT_SUPPORTED);
#endif
#ifdef EPFNOSUPPORT
g_assert_cmpint (g_io_error_from_errno (EPFNOSUPPORT), ==,
G_IO_ERROR_NOT_SUPPORTED);
#endif
#ifdef EAFNOSUPPORT
g_assert_cmpint (g_io_error_from_errno (EAFNOSUPPORT), ==,
G_IO_ERROR_NOT_SUPPORTED);
#endif
#ifdef ETIMEDOUT
g_assert_cmpint (g_io_error_from_errno (ETIMEDOUT), ==,
G_IO_ERROR_TIMED_OUT);
#endif
#ifdef EBUSY
g_assert_cmpint (g_io_error_from_errno (EBUSY), ==,
G_IO_ERROR_BUSY);
#endif
#ifdef EWOULDBLOCK
g_assert_cmpint (g_io_error_from_errno (EWOULDBLOCK), ==,
G_IO_ERROR_WOULD_BLOCK);
#endif
#ifdef EAGAIN
g_assert_cmpint (g_io_error_from_errno (EAGAIN), ==,
G_IO_ERROR_WOULD_BLOCK);
#endif
#ifdef EMFILE
g_assert_cmpint (g_io_error_from_errno (EMFILE), ==,
G_IO_ERROR_TOO_MANY_OPEN_FILES);
#endif
#ifdef EADDRINUSE
g_assert_cmpint (g_io_error_from_errno (EADDRINUSE), ==,
G_IO_ERROR_ADDRESS_IN_USE);
#endif
#ifdef EHOSTUNREACH
g_assert_cmpint (g_io_error_from_errno (EHOSTUNREACH), ==,
G_IO_ERROR_HOST_UNREACHABLE);
#endif
#ifdef ENETUNREACH
g_assert_cmpint (g_io_error_from_errno (ENETUNREACH), ==,
G_IO_ERROR_NETWORK_UNREACHABLE);
#endif
#ifdef ECONNREFUSED
g_assert_cmpint (g_io_error_from_errno (ECONNREFUSED), ==,
G_IO_ERROR_CONNECTION_REFUSED);
#endif
#ifdef EPIPE
g_assert_cmpint (g_io_error_from_errno (EPIPE), ==,
G_IO_ERROR_BROKEN_PIPE);
#endif
#ifdef ECONNRESET
g_assert_cmpint (g_io_error_from_errno (ECONNRESET), ==,
G_IO_ERROR_CONNECTION_CLOSED);
#endif
#ifdef ENOTCONN
g_assert_cmpint (g_io_error_from_errno (ENOTCONN), ==,
G_IO_ERROR_NOT_CONNECTED);
#endif
#ifdef EMSGSIZE
g_assert_cmpint (g_io_error_from_errno (EMSGSIZE), ==,
G_IO_ERROR_MESSAGE_TOO_LARGE);
#endif
#ifdef ENOTSOCK
g_assert_cmpint (g_io_error_from_errno (ENOTSOCK), ==,
G_IO_ERROR_INVALID_ARGUMENT);
#endif
#ifdef ESRCH
g_assert_cmpint (g_io_error_from_errno (ESRCH), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EINTR
g_assert_cmpint (g_io_error_from_errno (EINTR), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EIO
g_assert_cmpint (g_io_error_from_errno (EIO), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef E2BIG
g_assert_cmpint (g_io_error_from_errno (E2BIG), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOEXEC
g_assert_cmpint (g_io_error_from_errno (ENOEXEC), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EBADF
g_assert_cmpint (g_io_error_from_errno (EBADF), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ECHILD
g_assert_cmpint (g_io_error_from_errno (ECHILD), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EFAULT
g_assert_cmpint (g_io_error_from_errno (EFAULT), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOTBLK
g_assert_cmpint (g_io_error_from_errno (ENOTBLK), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EXDEV
g_assert_cmpint (g_io_error_from_errno (EXDEV), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENODEV
g_assert_cmpint (g_io_error_from_errno (ENODEV), ==,
G_IO_ERROR_NO_SUCH_DEVICE);
#endif
#ifdef ENFILE
g_assert_cmpint (g_io_error_from_errno (ENFILE), ==,
G_IO_ERROR_TOO_MANY_OPEN_FILES);
#endif
#ifdef ENOTTY
g_assert_cmpint (g_io_error_from_errno (ENOTTY), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ETXTBSY
g_assert_cmpint (g_io_error_from_errno (ETXTBSY), ==,
G_IO_ERROR_BUSY);
#endif
#ifdef EFBIG
g_assert_cmpint (g_io_error_from_errno (EFBIG), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ESPIPE
g_assert_cmpint (g_io_error_from_errno (ESPIPE), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EDOM
g_assert_cmpint (g_io_error_from_errno (EDOM), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ERANGE
g_assert_cmpint (g_io_error_from_errno (ERANGE), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EDEADLK
g_assert_cmpuint (g_io_error_from_errno (EDEADLK), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOLCK
g_assert_cmpuint (g_io_error_from_errno (ENOLCK), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOSYS
g_assert_cmpuint (g_io_error_from_errno (ENOSYS), ==,
G_IO_ERROR_NOT_SUPPORTED);
#endif
#ifdef ENOMSG
g_assert_cmpuint (g_io_error_from_errno (ENOMSG), ==,
G_IO_ERROR_INVALID_DATA);
#endif
#ifdef EIDRM
g_assert_cmpuint (g_io_error_from_errno (EIDRM), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ECHRNG
g_assert_cmpuint (g_io_error_from_errno (ECHRNG), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EL2NSYNC
g_assert_cmpuint (g_io_error_from_errno (EL2NSYNC), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EL3HLT
g_assert_cmpuint (g_io_error_from_errno (EL3HLT), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EL3RST
g_assert_cmpuint (g_io_error_from_errno (EL3RST), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ELNRNG
g_assert_cmpuint (g_io_error_from_errno (ELNRNG), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EUNATCH
g_assert_cmpuint (g_io_error_from_errno (EUNATCH), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOCSI
g_assert_cmpuint (g_io_error_from_errno (ENOCSI), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EL2HLT
g_assert_cmpuint (g_io_error_from_errno (EL2HLT), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EBADE
g_assert_cmpuint (g_io_error_from_errno (EBADE), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EBADR
g_assert_cmpuint (g_io_error_from_errno (EBADR), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EXFULL
g_assert_cmpuint (g_io_error_from_errno (EXFULL), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOANO
g_assert_cmpuint (g_io_error_from_errno (ENOANO), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EBADRQC
g_assert_cmpuint (g_io_error_from_errno (EBADRQC), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EBADSLT
g_assert_cmpuint (g_io_error_from_errno (EBADSLT), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EDEADLOCK
g_assert_cmpuint (g_io_error_from_errno (EDEADLOCK), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EBFONT
g_assert_cmpuint (g_io_error_from_errno (EBFONT), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOSTR
g_assert_cmpuint (g_io_error_from_errno (ENOSTR), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENODATA
g_assert_cmpuint (g_io_error_from_errno (ENODATA), ==,
G_IO_ERROR_INVALID_DATA);
#endif
#ifdef ETIME
g_assert_cmpuint (g_io_error_from_errno (ETIME), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOSR
g_assert_cmpuint (g_io_error_from_errno (ENOSR), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENONET
g_assert_cmpuint (g_io_error_from_errno (ENONET), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOPKG
g_assert_cmpuint (g_io_error_from_errno (ENOPKG), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EREMOTE
g_assert_cmpuint (g_io_error_from_errno (EREMOTE), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOLINK
g_assert_cmpuint (g_io_error_from_errno (ENOLINK), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EADV
g_assert_cmpuint (g_io_error_from_errno (EADV), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ESRMNT
g_assert_cmpuint (g_io_error_from_errno (ESRMNT), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ECOMM
g_assert_cmpuint (g_io_error_from_errno (ECOMM), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EPROTO
g_assert_cmpuint (g_io_error_from_errno (EPROTO), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EMULTIHOP
g_assert_cmpuint (g_io_error_from_errno (EMULTIHOP), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EDOTDOT
g_assert_cmpuint (g_io_error_from_errno (EDOTDOT), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EBADMSG
g_assert_cmpuint (g_io_error_from_errno (EBADMSG), ==,
G_IO_ERROR_INVALID_DATA);
#endif
#ifdef EOVERFLOW
g_assert_cmpuint (g_io_error_from_errno (EOVERFLOW), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOTUNIQ
g_assert_cmpuint (g_io_error_from_errno (ENOTUNIQ), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EBADFD
g_assert_cmpuint (g_io_error_from_errno (EBADFD), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EREMCHG
g_assert_cmpuint (g_io_error_from_errno (EREMCHG), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ELIBACC
g_assert_cmpuint (g_io_error_from_errno (ELIBACC), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ELIBBAD
g_assert_cmpuint (g_io_error_from_errno (ELIBBAD), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ELIBSCN
g_assert_cmpuint (g_io_error_from_errno (ELIBSCN), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ELIBMAX
g_assert_cmpuint (g_io_error_from_errno (ELIBMAX), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ELIBEXEC
g_assert_cmpuint (g_io_error_from_errno (ELIBEXEC), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EILSEQ
g_assert_cmpuint (g_io_error_from_errno (EILSEQ), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ERESTART
g_assert_cmpuint (g_io_error_from_errno (ERESTART), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ESTRPIPE
g_assert_cmpuint (g_io_error_from_errno (ESTRPIPE), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EUSERS
g_assert_cmpuint (g_io_error_from_errno (EUSERS), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EDESTADDRREQ
g_assert_cmpuint (g_io_error_from_errno (EDESTADDRREQ), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EPROTOTYPE
g_assert_cmpuint (g_io_error_from_errno (EPROTOTYPE), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOPROTOOPT
g_assert_cmpuint (g_io_error_from_errno (ENOPROTOOPT), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EADDRNOTAVAIL
g_assert_cmpuint (g_io_error_from_errno (EADDRNOTAVAIL), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENETDOWN
g_assert_cmpuint (g_io_error_from_errno (ENETDOWN), ==,
G_IO_ERROR_NETWORK_UNREACHABLE);
#endif
#ifdef ECONNABORTED
g_assert_cmpuint (g_io_error_from_errno (ECONNABORTED), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOBUFS
g_assert_cmpuint (g_io_error_from_errno (ENOBUFS), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EISCONN
g_assert_cmpuint (g_io_error_from_errno (EISCONN), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ESHUTDOWN
g_assert_cmpuint (g_io_error_from_errno (ESHUTDOWN), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ETOOMANYREFS
g_assert_cmpuint (g_io_error_from_errno (ETOOMANYREFS), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EHOSTDOWN
g_assert_cmpuint (g_io_error_from_errno (EHOSTDOWN), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EALREADY
g_assert_cmpuint (g_io_error_from_errno (EALREADY), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EINPROGRESS
g_assert_cmpuint (g_io_error_from_errno (EINPROGRESS), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ESTALE
g_assert_cmpuint (g_io_error_from_errno (ESTALE), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EUCLEAN
g_assert_cmpuint (g_io_error_from_errno (EUCLEAN), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOTNAM
g_assert_cmpuint (g_io_error_from_errno (ENOTNAM), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENAVAIL
g_assert_cmpuint (g_io_error_from_errno (ENAVAIL), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EISNAM
g_assert_cmpuint (g_io_error_from_errno (EISNAM), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EREMOTEIO
g_assert_cmpuint (g_io_error_from_errno (EREMOTEIO), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EDQUOT
g_assert_cmpuint (g_io_error_from_errno (EDQUOT), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOMEDIUM
g_assert_cmpuint (g_io_error_from_errno (ENOMEDIUM), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EMEDIUMTYPE
g_assert_cmpuint (g_io_error_from_errno (EMEDIUMTYPE), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOKEY
g_assert_cmpuint (g_io_error_from_errno (ENOKEY), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EKEYEXPIRED
g_assert_cmpuint (g_io_error_from_errno (EKEYEXPIRED), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EKEYREVOKED
g_assert_cmpuint (g_io_error_from_errno (EKEYREVOKED), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EKEYREJECTED
g_assert_cmpuint (g_io_error_from_errno (EKEYREJECTED), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EOWNERDEAD
g_assert_cmpuint (g_io_error_from_errno (EOWNERDEAD), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ENOTRECOVERABLE
g_assert_cmpuint (g_io_error_from_errno (ENOTRECOVERABLE), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef ERFKILL
g_assert_cmpuint (g_io_error_from_errno (ERFKILL), ==,
G_IO_ERROR_FAILED);
#endif
#ifdef EHWPOISON
g_assert_cmpuint (g_io_error_from_errno (EHWPOISON), ==,
G_IO_ERROR_FAILED);
#endif
}
static void
test_error_from_file_error (void)
{
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"*should not be reached*");
g_assert_cmpuint (g_io_error_from_file_error (-1), ==,
G_IO_ERROR_FAILED);
g_test_assert_expected_messages ();
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_EXIST), ==,
G_IO_ERROR_EXISTS);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_ISDIR), ==,
G_IO_ERROR_IS_DIRECTORY);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_ACCES), ==,
G_IO_ERROR_PERMISSION_DENIED);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_NAMETOOLONG), ==,
G_IO_ERROR_FILENAME_TOO_LONG);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_NOENT), ==,
G_IO_ERROR_NOT_FOUND);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_NOTDIR), ==,
G_IO_ERROR_NOT_DIRECTORY);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_NXIO), ==,
G_IO_ERROR_NOT_REGULAR_FILE);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_NODEV), ==,
G_IO_ERROR_NO_SUCH_DEVICE);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_ROFS), ==,
G_IO_ERROR_READ_ONLY);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_TXTBSY), ==,
G_IO_ERROR_BUSY);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_LOOP), ==,
G_IO_ERROR_TOO_MANY_LINKS);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_NOSPC), ==,
G_IO_ERROR_NO_SPACE);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_NOMEM), ==,
G_IO_ERROR_NO_SPACE);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_MFILE), ==,
G_IO_ERROR_TOO_MANY_OPEN_FILES);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_NFILE), ==,
G_IO_ERROR_TOO_MANY_OPEN_FILES);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_INVAL), ==,
G_IO_ERROR_INVALID_ARGUMENT);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_PIPE), ==,
G_IO_ERROR_BROKEN_PIPE);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_AGAIN), ==,
G_IO_ERROR_WOULD_BLOCK);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_PERM), ==,
G_IO_ERROR_PERMISSION_DENIED);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_NOSYS), ==,
G_IO_ERROR_NOT_SUPPORTED);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_BADF), ==,
G_IO_ERROR_FAILED);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_FAILED), ==,
G_IO_ERROR_FAILED);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_FAULT), ==,
G_IO_ERROR_FAILED);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_INTR), ==,
G_IO_ERROR_FAILED);
g_assert_cmpuint (g_io_error_from_file_error (G_FILE_ERROR_IO), ==,
G_IO_ERROR_FAILED);
}
static void
test_error_from_win32_error (void)
{
#ifdef G_OS_WIN32
g_assert_cmpint (g_io_error_from_win32_error (-1), ==, G_IO_ERROR_FAILED);
g_assert_cmpint (g_io_error_from_win32_error (WSAEADDRINUSE), ==,
G_IO_ERROR_ADDRESS_IN_USE);
g_assert_cmpint (g_io_error_from_win32_error (WSAEWOULDBLOCK), ==,
G_IO_ERROR_WOULD_BLOCK);
g_assert_cmpint (g_io_error_from_win32_error (WSAEACCES), ==,
G_IO_ERROR_PERMISSION_DENIED);
g_assert_cmpint (g_io_error_from_win32_error (WSA_INVALID_HANDLE), ==,
G_IO_ERROR_INVALID_ARGUMENT);
g_assert_cmpint (g_io_error_from_win32_error (WSA_INVALID_PARAMETER), ==,
G_IO_ERROR_INVALID_ARGUMENT);
g_assert_cmpint (g_io_error_from_win32_error (WSAEINVAL), ==,
G_IO_ERROR_INVALID_ARGUMENT);
g_assert_cmpint (g_io_error_from_win32_error (WSAEBADF), ==,
G_IO_ERROR_INVALID_ARGUMENT);
g_assert_cmpint (g_io_error_from_win32_error (WSAENOTSOCK), ==,
G_IO_ERROR_INVALID_ARGUMENT);
g_assert_cmpint (g_io_error_from_win32_error (WSAEPROTONOSUPPORT), ==,
G_IO_ERROR_NOT_SUPPORTED);
g_assert_cmpint (g_io_error_from_win32_error (WSAECANCELLED), ==,
G_IO_ERROR_CANCELLED);
g_assert_cmpint (g_io_error_from_win32_error (WSAESOCKTNOSUPPORT), ==,
G_IO_ERROR_NOT_SUPPORTED);
g_assert_cmpint (g_io_error_from_win32_error (WSAEOPNOTSUPP), ==,
G_IO_ERROR_NOT_SUPPORTED);
g_assert_cmpint (g_io_error_from_win32_error (WSAEPFNOSUPPORT), ==,
G_IO_ERROR_NOT_SUPPORTED);
g_assert_cmpint (g_io_error_from_win32_error (WSAEAFNOSUPPORT), ==,
G_IO_ERROR_NOT_SUPPORTED);
g_assert_cmpint (g_io_error_from_win32_error (WSAECONNRESET), ==,
G_IO_ERROR_CONNECTION_CLOSED);
g_assert_cmpint (g_io_error_from_win32_error (WSAENETRESET), ==,
G_IO_ERROR_CONNECTION_CLOSED);
g_assert_cmpint (g_io_error_from_win32_error (WSAESHUTDOWN), ==,
G_IO_ERROR_CONNECTION_CLOSED);
g_assert_cmpint (g_io_error_from_win32_error (WSAEHOSTUNREACH), ==,
G_IO_ERROR_HOST_UNREACHABLE);
g_assert_cmpint (g_io_error_from_win32_error (WSAENETUNREACH), ==,
G_IO_ERROR_NETWORK_UNREACHABLE);
g_assert_cmpint (g_io_error_from_win32_error (WSAECONNREFUSED), ==,
G_IO_ERROR_CONNECTION_REFUSED);
g_assert_cmpint (g_io_error_from_win32_error (WSAETIMEDOUT), ==,
G_IO_ERROR_TIMED_OUT);
g_assert_cmpint (g_io_error_from_win32_error (WSAENOTCONN), ==,
G_IO_ERROR_NOT_CONNECTED);
g_assert_cmpint (g_io_error_from_win32_error (ERROR_PIPE_LISTENING), ==,
G_IO_ERROR_NOT_CONNECTED);
g_assert_cmpint (g_io_error_from_win32_error (WSAEMSGSIZE), ==,
G_IO_ERROR_MESSAGE_TOO_LARGE);
#else
g_test_skip ("Windows error codes can only be checked on Windows");
#endif /* G_OS_WIN32 */
}
int
main (int argc,
char *argv[])
{
g_setenv ("LC_ALL", "C", TRUE);
g_test_init (&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);
g_test_add_func ("/error/from-errno", test_error_from_errno);
g_test_add_func ("/error/from-file-error", test_error_from_file_error);
g_test_add_func ("/error/from-win32-error", test_error_from_win32_error);
return g_test_run ();
}
Reference in New Issue View Git Blame Copy Permalink