GNOME.org
 

[glib: 3/24] tests: Add unit test for GIOErrorEnum conversion functions


commit 35c6c5c663bf5c4941827f90aedee018c9d30a16
Author: Marco Trevisan (Treviño) <mail 3v1n0 net>
Date:   Tue Jun 14 18:22:19 2022 +0200

    tests: Add unit test for GIOErrorEnum conversion functions

 gio/tests/error.c     | 788 ++++++++++++++++++++++++++++++++++++++++++++++++++
 gio/tests/meson.build |   1 +
 2 files changed, 789 insertions(+)
---
diff --git a/gio/tests/error.c b/gio/tests/error.c
new file mode 100644
index 0000000000..133c2d7776
--- /dev/null
+++ b/gio/tests/error.c
@@ -0,0 +1,788 @@
+/* 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 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_FAILED);
+#endif
+
+#ifdef ENFILE
+  g_assert_cmpint (g_io_error_from_errno (ENFILE), ==,
+                   G_IO_ERROR_FAILED);
+#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_FAILED);
+#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_FAILED);
+#endif
+
+#ifdef ENOMSG
+  g_assert_cmpuint (g_io_error_from_errno (ENOMSG), ==,
+                    G_IO_ERROR_FAILED);
+#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_FAILED);
+#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_FAILED);
+#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_FAILED);
+#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_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-win32-error", test_error_from_win32_error);
+
+  return g_test_run ();
+}
diff --git a/gio/tests/meson.build b/gio/tests/meson.build
index b90c3e5c60..ce102a6587 100644
--- a/gio/tests/meson.build
+++ b/gio/tests/meson.build
@@ -63,6 +63,7 @@ gio_tests = {
   },
   'data-input-stream' : {},
   'data-output-stream' : {},
+  'error': {},
   'fileattributematcher' : {},
   'filter-streams' : {},
   'giomodule' : {
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]