[Telepathy-commits] [telepathy-salut/master] move Gibber tests into lib/gibber
Dafydd Harries
daf at rhydd.org
Sun Feb 8 04:15:12 PST 2009
---
.gitignore | 9 +-
configure.ac | 3 +-
lib/gibber/Makefile.am | 2 +-
lib/gibber/tests/Makefile.am | 122 ++++
lib/gibber/tests/check-gibber-iq-helper.c | 432 +++++++++++++
lib/gibber/tests/check-gibber-listener.c | 211 +++++++
.../check-gibber-r-multicast-causal-transport.c | 550 +++++++++++++++++
lib/gibber/tests/check-gibber-r-multicast-packet.c | 228 +++++++
lib/gibber/tests/check-gibber-r-multicast-sender.c | 652 ++++++++++++++++++++
lib/gibber/tests/check-gibber-resolver.c | 91 +++
lib/gibber/tests/check-gibber-sasl-auth.c | 213 +++++++
.../tests/check-gibber-xmpp-connection-listener.c | 120 ++++
lib/gibber/tests/check-gibber-xmpp-connection.c | 126 ++++
lib/gibber/tests/check-gibber-xmpp-error.c | 139 +++++
lib/gibber/tests/check-gibber-xmpp-node.c | 167 +++++
lib/gibber/tests/check-gibber-xmpp-reader.c | 127 ++++
lib/gibber/tests/check-gibber-xmpp-stanza.c | 165 +++++
lib/gibber/tests/check-gibber.h | 20 +
lib/gibber/tests/check-helpers.c | 63 ++
lib/gibber/tests/check-helpers.h | 43 ++
lib/gibber/tests/check-main.c | 54 ++
lib/gibber/tests/inputs/Makefile.am | 5 +
lib/gibber/tests/inputs/groupchat-invite.input | 32 +
.../inputs/simple-message-attrnamespace.input | 17 +
lib/gibber/tests/inputs/simple-message.input | 16 +
.../tests/inputs/strange-streamopening.input | 9 +
lib/gibber/tests/inputs/tls-stream-start.input | 18 +
lib/gibber/tests/run-xmpp-connection-test.sh | 29 +
lib/gibber/tests/test-r-multicast-transport-io.c | 226 +++++++
lib/gibber/tests/test-resolver.c | 113 ++++
lib/gibber/tests/test-resolver.h | 59 ++
lib/gibber/tests/test-sasl-auth-server.c | 460 ++++++++++++++
lib/gibber/tests/test-sasl-auth-server.h | 73 +++
lib/gibber/tests/test-transport.c | 209 +++++++
lib/gibber/tests/test-transport.h | 73 +++
lib/gibber/tests/test-xmpp-connection.c | 157 +++++
tests/Makefile.am | 73 +--
tests/check-gibber-iq-helper.c | 432 -------------
tests/check-gibber-listener.c | 211 -------
tests/check-gibber-r-multicast-causal-transport.c | 550 -----------------
tests/check-gibber-r-multicast-packet.c | 228 -------
tests/check-gibber-r-multicast-sender.c | 652 --------------------
tests/check-gibber-resolver.c | 91 ---
tests/check-gibber-sasl-auth.c | 213 -------
tests/check-gibber-xmpp-connection-listener.c | 120 ----
tests/check-gibber-xmpp-connection.c | 126 ----
tests/check-gibber-xmpp-error.c | 139 -----
tests/check-gibber-xmpp-node.c | 167 -----
tests/check-gibber-xmpp-reader.c | 127 ----
tests/check-gibber-xmpp-stanza.c | 165 -----
tests/check-gibber.h | 20 -
tests/check-main.c | 31 -
tests/inputs/Makefile.am | 5 -
tests/inputs/groupchat-invite.input | 32 -
tests/inputs/simple-message-attrnamespace.input | 17 -
tests/inputs/simple-message.input | 16 -
tests/inputs/strange-streamopening.input | 9 -
tests/inputs/tls-stream-start.input | 18 -
tests/run-xmpp-connection-test.sh | 29 -
tests/test-r-multicast-transport-io.c | 226 -------
tests/test-resolver.c | 113 ----
tests/test-resolver.h | 59 --
tests/test-sasl-auth-server.c | 460 --------------
tests/test-sasl-auth-server.h | 73 ---
tests/test-transport.c | 209 -------
tests/test-transport.h | 73 ---
tests/test-xmpp-connection.c | 157 -----
67 files changed, 5032 insertions(+), 4842 deletions(-)
create mode 100644 lib/gibber/tests/Makefile.am
create mode 100644 lib/gibber/tests/check-gibber-iq-helper.c
create mode 100644 lib/gibber/tests/check-gibber-listener.c
create mode 100644 lib/gibber/tests/check-gibber-r-multicast-causal-transport.c
create mode 100644 lib/gibber/tests/check-gibber-r-multicast-packet.c
create mode 100644 lib/gibber/tests/check-gibber-r-multicast-sender.c
create mode 100644 lib/gibber/tests/check-gibber-resolver.c
create mode 100644 lib/gibber/tests/check-gibber-sasl-auth.c
create mode 100644 lib/gibber/tests/check-gibber-xmpp-connection-listener.c
create mode 100644 lib/gibber/tests/check-gibber-xmpp-connection.c
create mode 100644 lib/gibber/tests/check-gibber-xmpp-error.c
create mode 100644 lib/gibber/tests/check-gibber-xmpp-node.c
create mode 100644 lib/gibber/tests/check-gibber-xmpp-reader.c
create mode 100644 lib/gibber/tests/check-gibber-xmpp-stanza.c
create mode 100644 lib/gibber/tests/check-gibber.h
create mode 100644 lib/gibber/tests/check-helpers.c
create mode 100644 lib/gibber/tests/check-helpers.h
create mode 100644 lib/gibber/tests/check-main.c
create mode 100644 lib/gibber/tests/inputs/Makefile.am
create mode 100644 lib/gibber/tests/inputs/groupchat-invite.input
create mode 100644 lib/gibber/tests/inputs/simple-message-attrnamespace.input
create mode 100644 lib/gibber/tests/inputs/simple-message.input
create mode 100644 lib/gibber/tests/inputs/strange-streamopening.input
create mode 100644 lib/gibber/tests/inputs/tls-stream-start.input
create mode 100755 lib/gibber/tests/run-xmpp-connection-test.sh
create mode 100644 lib/gibber/tests/test-r-multicast-transport-io.c
create mode 100644 lib/gibber/tests/test-resolver.c
create mode 100644 lib/gibber/tests/test-resolver.h
create mode 100644 lib/gibber/tests/test-sasl-auth-server-signals-marshal.list
create mode 100644 lib/gibber/tests/test-sasl-auth-server.c
create mode 100644 lib/gibber/tests/test-sasl-auth-server.h
create mode 100644 lib/gibber/tests/test-transport.c
create mode 100644 lib/gibber/tests/test-transport.h
create mode 100644 lib/gibber/tests/test-xmpp-connection.c
delete mode 100644 tests/check-gibber-iq-helper.c
delete mode 100644 tests/check-gibber-listener.c
delete mode 100644 tests/check-gibber-r-multicast-causal-transport.c
delete mode 100644 tests/check-gibber-r-multicast-packet.c
delete mode 100644 tests/check-gibber-r-multicast-sender.c
delete mode 100644 tests/check-gibber-resolver.c
delete mode 100644 tests/check-gibber-sasl-auth.c
delete mode 100644 tests/check-gibber-xmpp-connection-listener.c
delete mode 100644 tests/check-gibber-xmpp-connection.c
delete mode 100644 tests/check-gibber-xmpp-error.c
delete mode 100644 tests/check-gibber-xmpp-node.c
delete mode 100644 tests/check-gibber-xmpp-reader.c
delete mode 100644 tests/check-gibber-xmpp-stanza.c
delete mode 100644 tests/check-gibber.h
delete mode 100644 tests/inputs/Makefile.am
delete mode 100644 tests/inputs/groupchat-invite.input
delete mode 100644 tests/inputs/simple-message-attrnamespace.input
delete mode 100644 tests/inputs/simple-message.input
delete mode 100644 tests/inputs/strange-streamopening.input
delete mode 100644 tests/inputs/tls-stream-start.input
delete mode 100755 tests/run-xmpp-connection-test.sh
delete mode 100644 tests/test-r-multicast-transport-io.c
delete mode 100644 tests/test-resolver.c
delete mode 100644 tests/test-resolver.h
delete mode 100644 tests/test-sasl-auth-server-signals-marshal.list
delete mode 100644 tests/test-sasl-auth-server.c
delete mode 100644 tests/test-sasl-auth-server.h
delete mode 100644 tests/test-transport.c
delete mode 100644 tests/test-transport.h
delete mode 100644 tests/test-xmpp-connection.c
diff --git a/.gitignore b/.gitignore
index a19c7f7..cc65c7c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -109,11 +109,8 @@ src/write-mgr-file
stamp-h1
telepathy-salut-*.tar.gz
tests/check-main
-tests/outputs
tests/sasl-test.db
-tests/test-xmpp-connection
tests/test-r-multicast-{packet,sender,transport-io}
-tests/test-r-multicast-transport-io
tests/twisted/tools/core
tests/twisted/tools/exec-with-log.sh
tests/twisted/tools/salut-testing.log
@@ -132,3 +129,9 @@ tests/test-r-multicast-packet
tests/test-r-sender
tests/test-r-transport-io
tests/telepathy-salut-debug
+
+lib/gibber/tests/check-main
+lib/gibber/tests/outputs
+lib/gibber/tests/test-xmpp-connection
+lib/gibber/tests/test-r-multicast-transport-io
+
diff --git a/configure.ac b/configure.ac
index d61cbdf..bcea22e 100644
--- a/configure.ac
+++ b/configure.ac
@@ -274,13 +274,14 @@ AC_OUTPUT( Makefile \
lib/Makefile \
lib/gibber/Makefile \
lib/gibber/examples/Makefile \
+ lib/gibber/tests/Makefile \
+ lib/gibber/tests/inputs/Makefile \
src/Makefile \
m4/Makefile \
data/Makefile \
extensions/Makefile \
tools/Makefile \
tests/Makefile \
- tests/inputs/Makefile \
tests/twisted/Makefile \
tests/twisted/tools/Makefile \
)
diff --git a/lib/gibber/Makefile.am b/lib/gibber/Makefile.am
index 975e8d3..f324db1 100644
--- a/lib/gibber/Makefile.am
+++ b/lib/gibber/Makefile.am
@@ -1,4 +1,4 @@
-SUBDIRS=examples
+SUBDIRS = examples tests
noinst_LTLIBRARIES = libgibber.la
diff --git a/lib/gibber/tests/Makefile.am b/lib/gibber/tests/Makefile.am
new file mode 100644
index 0000000..cc13722
--- /dev/null
+++ b/lib/gibber/tests/Makefile.am
@@ -0,0 +1,122 @@
+CLEANFILES=
+
+include $(top_srcdir)/rules/check.mak
+
+SUPPRESSIONS=valgrind.supp dlopen.supp
+
+# Teach it how to make libgibber.la
+$(top_builddir)/lib/gibber/libgibber.la:
+ ${MAKE} -C $(top_builddir)/lib/gibber libgibber.la
+
+.PHONY: $(top_builddir)/lib/gibber/libgibber.la
+
+TESTS = \
+ run-xmpp-connection-test.sh
+
+check_PROGRAMS = \
+ test-xmpp-connection \
+ test-r-multicast-transport-io
+
+check_SCRIPTS = run-xmpp-connection-test.sh
+
+EXTRA_DIST = simplemeshtest.py mesh.py $(check_SCRIPTS)
+
+test_xmpp_connection_SOURCES = \
+ test-xmpp-connection.c \
+ test-transport.c \
+ test-transport.h
+
+test_xmpp_connection_LDADD = \
+ $(top_builddir)/lib/gibber/libgibber.la \
+ $(AM_LDFLAGS)
+
+test_xmpp_connection_CFLAGS = \
+ $(AM_CFLAGS)
+
+test_r_multicast_transport_io_SOURCES = \
+ test-r-multicast-transport-io.c \
+ test-transport.c \
+ test-transport.h
+
+test_r_multicast_transport_io_LDADD = \
+ $(top_builddir)/lib/gibber/libgibber.la \
+ $(AM_LDFLAGS)
+
+test_r_multicast_transport_io_CFLAGS = \
+ $(AM_CFLAGS)
+
+
+if HAVE_CHECK
+check_PROGRAMS += check-main
+TESTS += check-main
+check_main_SOURCES = \
+ check-main.c \
+ check-helpers.c \
+ check-helpers.h \
+ check-gibber.h \
+ check-gibber-xmpp-node.c \
+ check-gibber-xmpp-reader.c \
+ check-gibber-r-multicast-causal-transport.c \
+ check-gibber-resolver.c \
+ test-resolver.c \
+ test-resolver.h \
+ test-transport.c \
+ test-transport.h \
+ check-gibber-xmpp-connection.c \
+ check-gibber-r-multicast-packet.c \
+ check-gibber-r-multicast-sender.c \
+ check-gibber-xmpp-stanza.c \
+ check-gibber-iq-helper.c \
+ check-gibber-listener.c \
+ check-gibber-xmpp-connection-listener.c \
+ check-gibber-xmpp-error.c
+
+check_main_LDADD = \
+ @CHECK_LIBS@ \
+ $(top_builddir)/lib/gibber/libgibber.la \
+ $(AM_LDFLAGS)
+
+check_main_CFLAGS = \
+ @CHECK_CFLAGS@ \
+ $(AM_CFLAGS)
+
+if HAVE_LIBSASL2
+ check_main_SOURCES += \
+ check-gibber-sasl-auth.c \
+ test-sasl-auth-server.c \
+ test-sasl-auth-server.h
+
+ check_main_LDADD += @LIBSASL2_LIBS@
+ check_main_CFLAGS += @LIBSASL2_CFLAGS@
+endif
+
+endif
+
+AM_CFLAGS = $(ERROR_CFLAGS) @GLIB_CFLAGS@ @LIBXML2_CFLAGS@ @DBUS_CFLAGS@ \
+ -I $(top_srcdir) -I $(top_builddir) \
+ -I $(top_srcdir)/lib -I $(top_builddir)/lib
+
+AM_LDFLAGS = @GLIB_LIBS@
+
+# Coding style checks
+check_c_sources = \
+ $(test_xmpp_connection_SOURCES) \
+ $(test_r_multicast_transport_io_SOURCES)
+
+if HAVE_CHECK
+ check_c_sources += $(check_main_SOURCES)
+endif
+
+include $(top_srcdir)/tools/check-coding-style.mk
+check-local: check-coding-style
+
+clean-local:
+ -rm -rf outputs
+ -rm -f sasl-test.db
+
+SUBDIRS = inputs
+
+$(check_SCRIPTS): always-run
+ chmod +x $(srcdir)/$@
+
+.PHONY: always-run
diff --git a/lib/gibber/tests/check-gibber-iq-helper.c b/lib/gibber/tests/check-gibber-iq-helper.c
new file mode 100644
index 0000000..5a79c45
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-iq-helper.c
@@ -0,0 +1,432 @@
+/*
+ * check-gibber-iq-helper.c - Test for GibberIqHelper
+ * Copyright (C) 2007 Collabora Ltd.
+ * @author Guillaume Desmottes <guillaume.desmottes at collabora.co.uk>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dbus/dbus-glib.h>
+
+#include <gibber/gibber-xmpp-stanza.h>
+#include <gibber/gibber-iq-helper.h>
+#include <gibber/gibber-xmpp-error.h>
+#include <gibber/gibber-namespaces.h>
+
+#include <check.h>
+#include "check-helpers.h"
+#include "check-gibber.h"
+
+#include "test-transport.h"
+
+gboolean received_reply = FALSE;
+
+static gboolean
+send_hook (GibberTransport *transport,
+ const guint8 *data,
+ gsize length,
+ GError **error,
+ gpointer user_data)
+{
+ test_transport_write (TEST_TRANSPORT (transport), data, length);
+ return TRUE;
+}
+
+static GibberXmppConnection *
+create_xmpp_connection (void)
+{
+ GibberXmppConnection *xmpp_connection;
+ TestTransport *transport;
+
+ transport = test_transport_new (send_hook, NULL);
+ xmpp_connection = gibber_xmpp_connection_new (GIBBER_TRANSPORT (transport));
+ gibber_xmpp_connection_open (xmpp_connection, "to", "from", "1.0");
+
+ g_object_unref (transport);
+
+ return xmpp_connection;
+}
+
+START_TEST (test_iq_helper_new)
+{
+ GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
+ GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
+ fail_unless (iq_helper != NULL);
+ g_object_unref (xmpp_connection);
+ g_object_unref (iq_helper);
+}
+END_TEST
+
+static void
+reply_func (GibberIqHelper *helper,
+ GibberXmppStanza *sent_stanza,
+ GibberXmppStanza *reply_stanza,
+ GObject *object,
+ gpointer user_data)
+{
+ received_reply = TRUE;
+}
+
+static void
+send_stanza_and_reply (GibberXmppConnection *xmpp_connection,
+ GibberIqHelper *iq_helper,
+ GibberXmppStanza *stanza,
+ GibberXmppStanza *reply)
+{
+ gboolean result;
+
+ if (stanza != NULL)
+ {
+ result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
+ NULL, NULL, NULL);
+ fail_unless (result);
+ }
+
+ if (reply != NULL)
+ {
+ result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
+ fail_unless (result);
+ }
+
+ while (g_main_context_iteration (NULL, FALSE))
+ ;
+
+}
+
+START_TEST (test_send_with_reply)
+{
+ GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
+ GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
+ GibberXmppStanza *stanza, *reply;
+
+ received_reply = FALSE;
+
+ stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
+ GIBBER_STANZA_SUB_TYPE_SET,
+ "from", "to",
+ GIBBER_NODE_ATTRIBUTE, "id", "69",
+ GIBBER_STANZA_END);
+
+ /* Reply of the stanza */
+ reply = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
+ GIBBER_STANZA_SUB_TYPE_RESULT,
+ "to", "from",
+ GIBBER_NODE_ATTRIBUTE, "id", "69",
+ GIBBER_STANZA_END);
+
+ send_stanza_and_reply (xmpp_connection, iq_helper, stanza, reply);
+ fail_unless (received_reply);
+
+ g_object_unref (stanza);
+ g_object_unref (reply);
+ g_object_unref (xmpp_connection);
+ g_object_unref (iq_helper);
+}
+END_TEST
+
+START_TEST (test_send_without_reply)
+{
+ GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
+ GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
+ GibberXmppStanza *stanza;
+
+ received_reply = FALSE;
+
+ stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
+ GIBBER_STANZA_SUB_TYPE_SET,
+ "from", "to",
+ GIBBER_NODE_ATTRIBUTE, "id", "69",
+ GIBBER_STANZA_END);
+
+ send_stanza_and_reply (xmpp_connection, iq_helper, stanza, NULL);
+ fail_unless (!received_reply);
+
+ g_object_unref (stanza);
+ g_object_unref (xmpp_connection);
+ g_object_unref (iq_helper);
+}
+END_TEST
+
+START_TEST (test_send_with_bad_reply_type)
+{
+ GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
+ GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
+ GibberXmppStanza *stanza, *reply;
+
+ received_reply = FALSE;
+
+ stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
+ GIBBER_STANZA_SUB_TYPE_SET,
+ "from", "to",
+ GIBBER_NODE_ATTRIBUTE, "id", "69",
+ GIBBER_STANZA_END);
+
+ /* Reply can't be of sub type "get" */
+ reply = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
+ GIBBER_STANZA_SUB_TYPE_GET,
+ "to", "from",
+ GIBBER_NODE_ATTRIBUTE, "id", "69",
+ GIBBER_STANZA_END);
+
+ send_stanza_and_reply (xmpp_connection, iq_helper, stanza, reply);
+ fail_unless (!received_reply);
+
+ g_object_unref (stanza);
+ g_object_unref (reply);
+ g_object_unref (xmpp_connection);
+ g_object_unref (iq_helper);
+}
+END_TEST
+
+START_TEST (test_send_without_id)
+{
+ GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
+ GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
+ GibberXmppStanza *stanza, *reply;
+ gboolean result;
+ const gchar *id;
+
+ received_reply = FALSE;
+
+ stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
+ GIBBER_STANZA_SUB_TYPE_SET,
+ "from", "to",
+ GIBBER_STANZA_END);
+
+ result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
+ NULL, NULL, NULL);
+ fail_unless (result);
+
+ /* gibber_iq_helper_send_with_reply generated an id */
+ id = gibber_xmpp_node_get_attribute (stanza->node, "id");
+
+ reply = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
+ GIBBER_STANZA_SUB_TYPE_RESULT,
+ "to", "from",
+ GIBBER_NODE_ATTRIBUTE, "id", id,
+ GIBBER_STANZA_END);
+
+ result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
+ fail_unless (result);
+
+ while (g_main_context_iteration (NULL, FALSE))
+ ;
+
+ fail_unless (received_reply);
+
+ g_object_unref (stanza);
+ g_object_unref (reply);
+ g_object_unref (xmpp_connection);
+ g_object_unref (iq_helper);
+}
+END_TEST
+
+START_TEST (test_new_result_reply)
+{
+ GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
+ GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
+ GibberXmppStanza *stanza, *reply;
+ gboolean result;
+
+ received_reply = FALSE;
+
+ stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
+ GIBBER_STANZA_SUB_TYPE_SET,
+ "from", "to",
+ GIBBER_STANZA_END);
+
+ result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
+ NULL, NULL, NULL);
+ fail_unless (result);
+
+ reply = gibber_iq_helper_new_result_reply (stanza);
+ fail_unless (reply != NULL);
+ fail_unless (strcmp (reply->node->name, "iq") == 0);
+ fail_unless (strcmp (gibber_xmpp_node_get_attribute (reply->node, "type"),
+ "result") == 0);
+ result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
+ fail_unless (result);
+
+ while (g_main_context_iteration (NULL, FALSE))
+ ;
+
+ fail_unless (received_reply);
+
+ g_object_unref (stanza);
+ g_object_unref (reply);
+ g_object_unref (xmpp_connection);
+ g_object_unref (iq_helper);
+}
+END_TEST
+
+START_TEST (test_new_error_reply)
+{
+ GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
+ GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
+ GibberXmppStanza *stanza, *reply;
+ GibberXmppNode *error_node, *node;
+ gboolean result;
+
+ received_reply = FALSE;
+
+ stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
+ GIBBER_STANZA_SUB_TYPE_SET,
+ "from", "to",
+ GIBBER_STANZA_END);
+
+ result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
+ NULL, NULL, NULL);
+ fail_unless (result);
+
+ reply = gibber_iq_helper_new_error_reply (stanza,
+ XMPP_ERROR_BAD_REQUEST, "test");
+ fail_unless (reply != NULL);
+ fail_unless (strcmp (reply->node->name, "iq") == 0);
+ fail_unless (strcmp (gibber_xmpp_node_get_attribute (reply->node, "type"),
+ "error") == 0);
+
+ error_node = gibber_xmpp_node_get_child (reply->node, "error");
+ fail_if (error_node == NULL);
+ fail_if (strcmp (gibber_xmpp_node_get_attribute (error_node, "code"),
+ "400") != 0);
+ fail_if (strcmp (gibber_xmpp_node_get_attribute (error_node, "type"),
+ "modify") != 0);
+
+ node = gibber_xmpp_node_get_child_ns (error_node, "bad-request",
+ GIBBER_XMPP_NS_STANZAS);
+ fail_if (node == NULL);
+
+ node = gibber_xmpp_node_get_child (error_node, "text");
+ fail_if (node == NULL);
+ fail_if (strcmp (node->content, "test") != 0);
+
+ result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
+ fail_unless (result);
+
+ while (g_main_context_iteration (NULL, FALSE))
+ ;
+
+ fail_unless (received_reply);
+
+ g_object_unref (stanza);
+ g_object_unref (reply);
+ g_object_unref (xmpp_connection);
+ g_object_unref (iq_helper);
+}
+END_TEST
+
+START_TEST (test_send_with_object_living)
+{
+ GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
+ GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
+ GibberXmppStanza *stanza, *reply;
+ gboolean result;
+ GObject *object;
+
+ received_reply = FALSE;
+
+ /* We don't care about the TestTransport, we just need a GObject */
+ object = g_object_new (TEST_TYPE_TRANSPORT, NULL);
+
+ stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
+ GIBBER_STANZA_SUB_TYPE_SET,
+ "from", "to",
+ GIBBER_STANZA_END);
+
+ result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
+ object, NULL, NULL);
+ fail_unless (result);
+
+ reply = gibber_iq_helper_new_result_reply (stanza);
+ fail_unless (reply != NULL);
+ result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
+ fail_unless (result);
+
+ while (g_main_context_iteration (NULL, FALSE))
+ ;
+
+ fail_unless (received_reply);
+
+ g_object_unref (stanza);
+ g_object_unref (reply);
+ g_object_unref (object);
+ g_object_unref (xmpp_connection);
+ g_object_unref (iq_helper);
+}
+END_TEST
+
+START_TEST (test_send_with_object_destroyed)
+{
+ GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
+ GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
+ GibberXmppStanza *stanza, *reply;
+ gboolean result;
+ GObject *object;
+
+ received_reply = FALSE;
+
+ /* We don't care about the TestTransport, we just need a GObject */
+ object = g_object_new (TEST_TYPE_TRANSPORT, NULL);
+
+ stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
+ GIBBER_STANZA_SUB_TYPE_SET,
+ "from", "to",
+ GIBBER_STANZA_END);
+
+ result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
+ object, NULL, NULL);
+ fail_unless (result);
+
+ g_object_unref (object);
+
+ reply = gibber_iq_helper_new_result_reply (stanza);
+ fail_unless (reply != NULL);
+ result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
+ fail_unless (result);
+
+ while (g_main_context_iteration (NULL, FALSE))
+ ;
+
+ /* Object was destroyed before we send the reply so we don't receive
+ * the reply */
+ fail_unless (!received_reply);
+
+ g_object_unref (stanza);
+ g_object_unref (reply);
+ g_object_unref (xmpp_connection);
+ g_object_unref (iq_helper);
+}
+END_TEST
+
+TCase *
+make_gibber_iq_helper_tcase (void)
+{
+ TCase *tc = tcase_create ("IQ helper");
+ tcase_add_test (tc, test_iq_helper_new);
+ tcase_add_test (tc, test_send_with_reply);
+ tcase_add_test (tc, test_send_without_reply);
+ tcase_add_test (tc, test_send_with_bad_reply_type);
+ tcase_add_test (tc, test_send_without_id);
+ tcase_add_test (tc, test_new_result_reply);
+ tcase_add_test (tc, test_new_error_reply);
+ tcase_add_test (tc, test_send_with_object_living);
+ tcase_add_test (tc, test_send_with_object_destroyed);
+
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-listener.c b/lib/gibber/tests/check-gibber-listener.c
new file mode 100644
index 0000000..4a1bce0
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-listener.c
@@ -0,0 +1,211 @@
+/*
+ * check-gibber-listener.c - Test for GibberListener
+ * Copyright (C) 2007, 2008 Collabora Ltd.
+ * @author Guillaume Desmottes <guillaume.desmottes at collabora.co.uk>
+ * @author Sjoerd Simons <sjoerd.simons at collabora.co.uk>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+
+#include <gibber/gibber-tcp-transport.h>
+#include <gibber/gibber-unix-transport.h>
+#include <gibber/gibber-listener.h>
+
+#include <check.h>
+#include "check-gibber.h"
+
+gboolean got_connection;
+gboolean signalled;
+
+static void
+new_connection_cb (GibberListener *listener,
+ GibberTransport *connection,
+ struct sockaddr *addr,
+ guint size,
+ GMainLoop *loop)
+{
+ signalled = TRUE;
+ got_connection = TRUE;
+ g_main_loop_quit (loop);
+}
+
+static void
+disconnected_cb (GibberTransport *transport, GMainLoop *loop)
+{
+ signalled = TRUE;
+ got_connection = FALSE;
+ g_main_loop_quit (loop);
+}
+
+static GibberTransport *
+connect_to_port (int port, GMainLoop *loop)
+{
+ GibberTCPTransport *transport;
+ gchar sport[16];
+
+ g_snprintf (sport, 16, "%d", port);
+
+ transport = gibber_tcp_transport_new ();
+ g_signal_connect (transport, "disconnected",
+ G_CALLBACK (disconnected_cb), loop);
+
+ gibber_tcp_transport_connect (transport, "127.0.0.1", sport);
+
+ return GIBBER_TRANSPORT (transport);
+}
+
+START_TEST (test_unix_listen)
+{
+ GibberListener *listener_unix;
+ GibberUnixTransport *unix_transport;
+ int ret;
+ GMainLoop *mainloop;
+ GError *error = NULL;
+ gchar *path = "/tmp/check-gibber-listener-socket";
+
+ ret = unlink (path);
+ fail_if (ret == -1 && errno != ENOENT);
+
+ mainloop = g_main_loop_new (NULL, FALSE);
+
+ listener_unix = gibber_listener_new ();
+ fail_if (listener_unix == NULL);
+
+ g_signal_connect (listener_unix, "new-connection",
+ G_CALLBACK (new_connection_cb), mainloop);
+
+ ret = gibber_listener_listen_socket (listener_unix, path, FALSE, &error);
+ fail_if (ret != TRUE);
+
+ unix_transport = gibber_unix_transport_new ();
+ ret = gibber_unix_transport_connect (unix_transport, path, &error);
+ fail_if (ret != TRUE);
+
+ if (!signalled)
+ g_main_loop_run (mainloop);
+
+ fail_if (!got_connection, "Failed to connect");
+
+ g_object_unref (listener_unix);
+ g_object_unref (unix_transport);
+ g_main_loop_unref (mainloop);
+} END_TEST
+
+START_TEST (test_tcp_listen)
+{
+ GibberListener *listener;
+ GibberListener *listener_without_port;
+ GibberListener *listener2;
+ int ret, port;
+ GMainLoop *mainloop;
+ GibberTransport *transport;
+ GError *error = NULL;
+
+ mainloop = g_main_loop_new (NULL, FALSE);
+
+ /* tcp socket tests without a specified port */
+ listener_without_port = gibber_listener_new ();
+ fail_if (listener_without_port == NULL);
+
+ g_signal_connect (listener_without_port, "new-connection",
+ G_CALLBACK (new_connection_cb), mainloop);
+
+ ret = gibber_listener_listen_tcp (listener_without_port, 0, &error);
+ fail_if (ret != TRUE);
+ port = gibber_listener_get_port (listener_without_port);
+
+ signalled = FALSE;
+ transport = connect_to_port (port, mainloop);
+ if (!signalled)
+ g_main_loop_run (mainloop);
+
+ fail_if (!got_connection, "Failed to connect");
+
+ g_object_unref (listener_without_port);
+ g_object_unref (transport);
+
+ /* tcp socket tests with a specified port */
+ listener = gibber_listener_new ();
+ fail_if (listener == NULL);
+
+ g_signal_connect (listener, "new-connection", G_CALLBACK (new_connection_cb),
+ mainloop);
+
+ for (port = 5298; port < 5400; port++)
+ {
+ if (gibber_listener_listen_tcp (listener, port, &error))
+ break;
+
+ fail_if (!g_error_matches (error, GIBBER_LISTENER_ERROR,
+ GIBBER_LISTENER_ERROR_ADDRESS_IN_USE));
+ g_error_free (error);
+ error = NULL;
+ }
+ fail_if (port >= 5400);
+ fail_if (port != gibber_listener_get_port (listener));
+
+ /* try a second listener on the same port */
+ listener2 = gibber_listener_new ();
+ fail_if (listener2 == NULL);
+ fail_if (gibber_listener_listen_tcp (listener2, port, &error));
+ fail_if (!g_error_matches (error, GIBBER_LISTENER_ERROR,
+ GIBBER_LISTENER_ERROR_ADDRESS_IN_USE));
+ g_object_unref (listener2);
+ g_error_free (error);
+ error = NULL;
+
+ signalled = FALSE;
+ transport = connect_to_port (port, mainloop);
+ if (!signalled)
+ g_main_loop_run (mainloop);
+
+ fail_if (!got_connection, "Failed to connect");
+
+ g_object_unref (listener);
+ g_object_unref (transport);
+
+ /* listener is destroyed, connection should be refused now */
+ signalled = FALSE;
+ transport = connect_to_port (port, mainloop);
+
+ if (!signalled)
+ g_main_loop_run (mainloop);
+
+ fail_if (got_connection, "Connected while listening should have stopped");
+
+ g_object_unref (transport);
+ g_main_loop_unref (mainloop);
+
+} END_TEST
+
+TCase *
+make_gibber_listener_tcase (void)
+{
+ TCase *tc = tcase_create ("GibberListener");
+ tcase_add_test (tc, test_tcp_listen);
+ tcase_add_test (tc, test_unix_listen);
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-r-multicast-causal-transport.c b/lib/gibber/tests/check-gibber-r-multicast-causal-transport.c
new file mode 100644
index 0000000..8dc9278
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-r-multicast-causal-transport.c
@@ -0,0 +1,550 @@
+/*
+ * check-gibber-r-multicast-causal-transport.c
+ * - R Multicast CausalTransport test
+ * Copyright (C) 2007 Collabora Ltd.
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <gibber/gibber-r-multicast-causal-transport.h>
+#include <gibber/gibber-r-multicast-packet.h>
+#include "test-transport.h"
+#include "check-gibber.h"
+
+#include <check.h>
+
+/* Numer of polls we expect the id generation to do */
+#define ID_GENERATION_EXPECTED_POLLS 3
+
+/* Assume mtu is 1500, we want at least 3 packets */
+#define TEST_DATA_SIZE 3300
+GMainLoop *loop;
+
+static GibberRMulticastCausalTransport *
+create_rmulticast_transport (TestTransport **testtransport,
+ const gchar *name,
+ test_transport_send_hook test_send_hook,
+ gpointer user_data)
+{
+ TestTransport *t;
+ GibberRMulticastCausalTransport *rmctransport;
+
+ t = test_transport_new (test_send_hook, user_data);
+ fail_unless (t != NULL);
+ GIBBER_TRANSPORT (t)->max_packet_size = 150;
+
+ rmctransport = gibber_r_multicast_causal_transport_new
+ (GIBBER_TRANSPORT(t), "test123");
+ g_object_unref (t);
+
+ if (testtransport != NULL)
+ {
+ *testtransport = t;
+ }
+
+ test_transport_set_echoing (t, TRUE);
+
+ return rmctransport;
+}
+
+static void
+rmulticast_connect (GibberRMulticastCausalTransport *transport)
+{
+
+ fail_unless (transport != NULL);
+
+ fail_unless (gibber_r_multicast_causal_transport_connect (transport,
+ FALSE, NULL));
+}
+
+
+/* test depends test */
+struct {
+ gchar *name;
+ guint32 sender_id;
+ guint32 packet_id;
+ gboolean seen;
+} senders[] = {
+ { "test0", 1, 0xff, FALSE },
+ { "test1", 2, 0xffff, FALSE },
+ { "test2", 3, 0xffffff, FALSE },
+ { "test3", 4, 0xaaaaaa, FALSE },
+ { "test4", 5, 0xabcdab, FALSE },
+ { NULL, 0, 0, FALSE }
+};
+
+static gboolean
+depends_send_hook (GibberTransport *transport,
+ const guint8 *data,
+ gsize length,
+ GError **error,
+ gpointer user_data)
+{
+ GibberRMulticastPacket *packet;
+ guint i, n;
+
+ packet = gibber_r_multicast_packet_parse (data, length, NULL);
+ fail_unless (packet != NULL);
+
+ if (packet->type == PACKET_TYPE_WHOIS_REQUEST)
+ {
+ GibberRMulticastPacket *reply;
+ guint8 *pdata;
+ gsize psize;
+
+ for (i = 0; senders[i].name != NULL; i++)
+ {
+ if (senders[i].sender_id == packet->data.whois_request.sender_id)
+ {
+ break;
+ }
+ }
+
+ if (senders[i].name == NULL && packet->sender == 0)
+ {
+ /* unique id polling */
+ goto out;
+ }
+
+ fail_unless (senders[i].name != NULL);
+
+ reply = gibber_r_multicast_packet_new (PACKET_TYPE_WHOIS_REPLY,
+ senders[i].sender_id, transport->max_packet_size);
+
+ gibber_r_multicast_packet_set_whois_reply_info (reply,
+ senders[i].name);
+
+ pdata = gibber_r_multicast_packet_get_raw_data (reply, &psize);
+ test_transport_write (TEST_TRANSPORT(transport), pdata, psize);
+ g_object_unref (reply);
+ }
+
+ if (packet->type != PACKET_TYPE_DATA)
+ {
+ goto out;
+ }
+
+ fail_unless (packet->depends->len > 0);
+
+ for (n = 0; n < packet->depends->len; n++)
+ {
+ for (i = 0; senders[i].name != NULL ; i++)
+ {
+ GibberRMulticastPacketSenderInfo *sender_info =
+ g_array_index (packet->depends,
+ GibberRMulticastPacketSenderInfo *, n);
+ if (senders[i].sender_id == sender_info->sender_id)
+ {
+ fail_unless (senders[i].seen == FALSE);
+ fail_unless (senders[i].packet_id + 1 == sender_info->packet_id);
+ senders[i].seen = TRUE;
+ break;
+ }
+ }
+ fail_unless (senders[i].name != NULL);
+ }
+
+ for (i = 0; senders[i].name != NULL ; i++)
+ {
+ fail_unless (senders[i].seen, "Not all senders in depends");
+ }
+
+ g_main_loop_quit (loop);
+out:
+ g_object_unref (packet);
+ return TRUE;
+}
+
+static gboolean
+depends_send_test_data (gpointer data)
+{
+ GibberRMulticastCausalTransport *t =
+ GIBBER_R_MULTICAST_CAUSAL_TRANSPORT (data);
+ guint8 testdata[] = { 1, 2, 3 };
+
+ fail_unless (gibber_transport_send (GIBBER_TRANSPORT (t), testdata,
+ 3, NULL));
+
+ return FALSE;
+}
+
+static void
+depends_connected (GibberTransport *transport,
+ gpointer user_data)
+{
+ GibberRMulticastCausalTransport *rmctransport
+ = GIBBER_R_MULTICAST_CAUSAL_TRANSPORT (transport);
+ TestTransport *testtransport = TEST_TRANSPORT (user_data);
+ int i;
+
+ /* First input some data packets, so the transport is forced to generate
+ * dependency info */
+ for (i = 0 ; senders[i].name != NULL; i++)
+ {
+ GibberRMulticastPacket *packet;
+ guint8 *data;
+ gsize size;
+
+ packet = gibber_r_multicast_packet_new (PACKET_TYPE_DATA,
+ senders[i].sender_id,
+ GIBBER_TRANSPORT (testtransport)->max_packet_size);
+
+ gibber_r_multicast_causal_transport_add_sender (rmctransport,
+ senders[i].sender_id);
+ gibber_r_multicast_causal_transport_update_sender_start (rmctransport,
+ senders[i].sender_id, senders[i].packet_id);
+
+ gibber_r_multicast_packet_set_packet_id (packet, senders[i].packet_id);
+ gibber_r_multicast_packet_set_data_info (packet, 0, 0, 1);
+
+ data = gibber_r_multicast_packet_get_raw_data (packet, &size);
+ test_transport_write (testtransport, data, size);
+ g_object_unref (packet);
+ }
+
+ /* Wait more then 200 ms, so all senders can get go to running */
+ g_timeout_add (300, depends_send_test_data, rmctransport);
+}
+
+START_TEST (test_depends)
+{
+ GibberRMulticastCausalTransport *rmctransport;
+ TestTransport *testtransport;
+ int i;
+
+ loop = g_main_loop_new (NULL, FALSE);
+
+ rmctransport = create_rmulticast_transport (&testtransport, "test123",
+ depends_send_hook, NULL);
+
+ g_signal_connect (rmctransport, "connected",
+ G_CALLBACK (depends_connected), testtransport);
+
+ rmulticast_connect (rmctransport);
+
+ g_main_loop_run (loop);
+ g_main_loop_unref (loop);
+
+ for (i = 0 ; senders[i].name != NULL; i++)
+ {
+ fail_unless (senders[i].seen);
+ }
+
+ g_object_unref (rmctransport);
+}
+END_TEST
+
+
+/* test fragmentation testing */
+static gboolean
+fragmentation_send_hook (GibberTransport *transport,
+ const guint8 *data,
+ gsize length,
+ GError **error,
+ gpointer user_data)
+{
+ GibberRMulticastPacket *packet;
+ static gsize bytes = 0;
+ static guint8 next_byte = 0;
+ gsize i;
+ gsize size;
+ guint8 *payload;
+
+ packet = gibber_r_multicast_packet_parse (data, length, NULL);
+ fail_unless (packet != NULL);
+
+ if (packet->type != PACKET_TYPE_DATA)
+ {
+ goto out;
+ }
+
+ payload = gibber_r_multicast_packet_get_payload (packet, &size);
+
+ if (bytes == 0)
+ fail_unless
+ (packet->data.data.flags == GIBBER_R_MULTICAST_DATA_PACKET_START);
+ else if (bytes + size < TEST_DATA_SIZE)
+ fail_unless (packet->data.data.flags == 0);
+
+ bytes += size;
+ fail_unless (bytes <= TEST_DATA_SIZE);
+
+ /* check our bytes */
+ for (i = 0; i < size; i++)
+ {
+ fail_unless (payload[i] == next_byte);
+ next_byte++;
+ }
+
+ if (bytes == TEST_DATA_SIZE)
+ {
+ fail_unless
+ (packet->data.data.flags == GIBBER_R_MULTICAST_DATA_PACKET_END);
+ g_object_unref (packet);
+ g_main_loop_quit (loop);
+ return FALSE;
+ }
+
+out:
+ g_object_unref (packet);
+ return TRUE;
+}
+
+static void
+fragmentation_connected (GibberTransport *transport,
+ gpointer user_data)
+{
+ GibberRMulticastCausalTransport *rmctransport
+ = GIBBER_R_MULTICAST_CAUSAL_TRANSPORT (transport);
+ guint8 testdata[TEST_DATA_SIZE];
+ int i;
+
+ for (i = 0; i < TEST_DATA_SIZE; i++)
+ {
+ testdata[i] = (guint8) (i & 0xff);
+ }
+
+ fail_unless (gibber_transport_send (GIBBER_TRANSPORT (rmctransport),
+ (guint8 *) testdata, TEST_DATA_SIZE, NULL));
+}
+
+START_TEST (test_fragmentation)
+{
+ GibberRMulticastCausalTransport *rmctransport;
+
+ loop = g_main_loop_new (NULL, FALSE);
+
+ rmctransport = create_rmulticast_transport (NULL, "test123",
+ fragmentation_send_hook, NULL);
+
+ g_signal_connect (rmctransport, "connected",
+ G_CALLBACK (fragmentation_connected), NULL);
+
+ rmulticast_connect (rmctransport);
+
+ g_main_loop_run (loop);
+ g_main_loop_unref (loop);
+
+ g_object_unref (rmctransport);
+}
+END_TEST
+
+
+/* test unique id */
+static gboolean
+unique_id_send_hook (GibberTransport *transport,
+ const guint8 *data,
+ gsize length,
+ GError **error,
+ gpointer user_data)
+{
+ GibberRMulticastPacket *packet;
+ guint32 *test_id = (guint32 *) user_data;
+
+
+ packet = gibber_r_multicast_packet_parse (data, length, NULL);
+ fail_unless (packet != NULL);
+
+ if (*test_id == 0)
+ {
+ /* force collision */
+ GibberRMulticastPacket *reply;
+ guint8 *pdata;
+ gsize psize;
+
+ /* First packet must be a whois request to see if the id is taken */
+ fail_unless (packet->type == PACKET_TYPE_WHOIS_REQUEST);
+ /* Sender must be 0 as it couldn't choose a id just yet */
+ fail_unless (packet->sender == 0);
+
+ *test_id = packet->data.whois_request.sender_id;
+
+ reply = gibber_r_multicast_packet_new (PACKET_TYPE_WHOIS_REPLY,
+ *test_id, transport->max_packet_size);
+
+ gibber_r_multicast_packet_set_whois_reply_info (reply, "romeo");
+
+ pdata = gibber_r_multicast_packet_get_raw_data (reply, &psize);
+ test_transport_write (TEST_TRANSPORT(transport), pdata, psize);
+ g_object_unref (reply);
+ }
+ else
+ {
+ fail_unless (*test_id != packet->sender);
+ switch (packet->type)
+ {
+ case PACKET_TYPE_WHOIS_REQUEST:
+ fail_unless (*test_id != packet->data.whois_request.sender_id);
+ break;
+ case PACKET_TYPE_WHOIS_REPLY:
+ /* transport sends a unsolicited whois reply after choosing a
+ * identifier */
+ g_main_loop_quit (loop);
+ break;
+ default:
+ fail ("Unexpected packet type: %x", packet->type);
+ }
+ }
+
+ g_object_unref (packet);
+ return TRUE;
+}
+
+START_TEST (test_unique_id)
+{
+ /* Test if the multicast transport correctly handles the case that it gets a
+ * WHOIS_REPLY on one of it's WHOIS_REQUESTS when it's determining a unique
+ * id for itself */
+ GibberRMulticastCausalTransport *rmctransport;
+ guint32 test_id;
+
+ test_id = 0;
+ loop = g_main_loop_new (NULL, FALSE);
+
+ rmctransport = create_rmulticast_transport (NULL, "test123",
+ unique_id_send_hook, &test_id);
+
+ rmulticast_connect (rmctransport);
+
+ g_main_loop_run (loop);
+ g_main_loop_unref (loop);
+
+ g_object_unref (rmctransport);
+}
+END_TEST
+
+/* test id generation conflict */
+typedef struct {
+ guint32 id;
+ gint count;
+ gint wait;
+} unique_id_conflict_test_t;
+
+static gboolean
+id_generation_conflict_send_hook (GibberTransport *transport,
+ const guint8 *data,
+ gsize length,
+ GError **error,
+ gpointer user_data)
+{
+ GibberRMulticastPacket *packet;
+ unique_id_conflict_test_t *test = (unique_id_conflict_test_t *) user_data;
+
+ packet = gibber_r_multicast_packet_parse (data, length, NULL);
+ fail_unless (packet != NULL);
+
+ if (test->id == 0)
+ {
+ /* First packet must be a whois request to see if the id is taken */
+ fail_unless (packet->type == PACKET_TYPE_WHOIS_REQUEST);
+ /* Sender must be 0 as it couldn't choose a id just yet */
+ fail_unless (packet->sender == 0);
+
+ test->id = packet->data.whois_request.sender_id;
+ }
+
+ switch (packet->type)
+ {
+ case PACKET_TYPE_WHOIS_REQUEST:
+ test->count++;
+
+ if (test->count < test->wait)
+ {
+ fail_unless (test->id == packet->data.whois_request.sender_id);
+ }
+ else if (test->count == test->wait)
+ {
+ /* force collision */
+ GibberRMulticastPacket *reply;
+ guint8 *pdata;
+ gsize psize;
+
+ fail_unless (test->id == packet->data.whois_request.sender_id);
+
+ reply = gibber_r_multicast_packet_new (PACKET_TYPE_WHOIS_REQUEST,
+ 0, transport->max_packet_size);
+
+ gibber_r_multicast_packet_set_whois_request_info (reply, test->id);
+
+ pdata = gibber_r_multicast_packet_get_raw_data (reply, &psize);
+ test_transport_write (TEST_TRANSPORT(transport), pdata, psize);
+ g_object_unref (reply);
+ }
+ else if (test->count > test->wait)
+ {
+ fail_unless (test->id != packet->data.whois_request.sender_id);
+ }
+
+ break;
+
+ case PACKET_TYPE_WHOIS_REPLY:
+ /* transport sends a unsolicited whois reply after choosing a
+ * identifier */
+ fail_unless (packet->sender != test->id);
+ fail_unless (test->count ==
+ ID_GENERATION_EXPECTED_POLLS + test->wait);
+ g_main_loop_quit (loop);
+ break;
+
+ default:
+ fail ("Unexpected packet type: %x", packet->type);
+ }
+
+ g_object_unref (packet);
+ return TRUE;
+}
+
+START_TEST (test_id_generation_conflict)
+{
+ /* Test if the multicast transport correctly handles the case that it sees
+ * another WHOIS_REQUEST on one of its WHOIS_REQUESTS when it's determining
+ * a unique id for itself */
+ GibberRMulticastCausalTransport *rmtransport;
+ unique_id_conflict_test_t test;
+
+ test.id = 0;
+ test.count = 0;
+ test.wait = _i + 1;
+
+ loop = g_main_loop_new (NULL, FALSE);
+
+ rmtransport = create_rmulticast_transport (NULL, "test123",
+ id_generation_conflict_send_hook, &test);
+
+ rmulticast_connect (rmtransport);
+
+ g_main_loop_run (loop);
+ g_main_loop_unref (loop);
+
+ g_object_unref (rmtransport);
+}
+END_TEST
+
+
+TCase *
+make_gibber_r_multicast_causal_transport_tcase (void)
+{
+ TCase *tc = tcase_create ("Gibber R Multicast Causal transport");
+ tcase_add_test (tc, test_unique_id);
+ tcase_add_loop_test (tc, test_id_generation_conflict, 0,
+ ID_GENERATION_EXPECTED_POLLS);
+ tcase_add_test (tc, test_fragmentation);
+ tcase_add_test (tc, test_depends);
+
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-r-multicast-packet.c b/lib/gibber/tests/check-gibber-r-multicast-packet.c
new file mode 100644
index 0000000..52bfef4
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-r-multicast-packet.c
@@ -0,0 +1,228 @@
+#include <stdio.h>
+#include <string.h>
+
+#include <gibber/gibber-r-multicast-packet.h>
+
+#include <check.h>
+#include "check-gibber.h"
+
+#define COMPARE(x) G_STMT_START { \
+ fail_unless (a->x == b->x); \
+} G_STMT_END
+
+typedef struct {
+ guint32 sender_id;
+ guint32 packet_id;
+ gboolean seen;
+} sender_t;
+
+typedef struct {
+ guint32 a;
+ guint32 b;
+ gint32 result;
+} diff_testcase;
+
+#define NUMBER_OF_DIFF_TESTS 15
+
+START_TEST (test_r_multicast_packet_diff)
+{
+ diff_testcase cases[NUMBER_OF_DIFF_TESTS] =
+ { { 0, 0, 0 },
+ { 10, 10, 0 },
+ { 5, 10, 5 },
+ { 10, 5, -5 },
+ { G_MAXUINT32 - 10, 10, 21 },
+ { G_MAXUINT32, 0, 1 },
+ { 0 , G_MAXUINT32, -1 },
+ { G_MAXUINT32, 10, 11 },
+ { 10, G_MAXUINT32, -11 },
+ { G_MAXUINT32/2, G_MAXUINT32, G_MAXINT32 },
+ { G_MAXUINT32, G_MAXUINT32/2, -G_MAXINT32 },
+ { G_MAXUINT32/2 - 1, G_MAXUINT32, G_MAXINT32 },
+ { G_MAXUINT32, G_MAXUINT32/2 - 1, -G_MAXINT32 },
+ { G_MAXUINT32 - 5, 5, 11 },
+ { 5, G_MAXUINT32 - 5, -11 },
+
+ };
+
+ diff_testcase *c = cases + _i;
+ gint32 result = gibber_r_multicast_packet_diff (c->a, c->b);
+ fail_unless (c->result == result);
+}
+END_TEST
+
+START_TEST (test_data_packet)
+{
+ GibberRMulticastPacket *a;
+ GibberRMulticastPacket *b;
+ guint32 sender_id = 1234;
+ guint32 packet_id = 1200;
+ guint8 flags = GIBBER_R_MULTICAST_DATA_PACKET_START;
+ guint32 total_size = 800;
+ guint16 stream_id = 56;
+ guint8 *data;
+ gsize len;
+ guint8 *pdata;
+ gsize plen;
+ guint i,n;
+ sender_t senders[] =
+ { { 0x300, 500, FALSE }, { 0x400, 600, FALSE }, { 0, 0, FALSE } };
+ gchar *payload = "1234567890";
+
+ g_type_init ();
+
+ a = gibber_r_multicast_packet_new (PACKET_TYPE_DATA, sender_id, 1500);
+ gibber_r_multicast_packet_set_packet_id (a, packet_id);
+ gibber_r_multicast_packet_set_data_info (a, stream_id, flags, total_size);
+
+ for (i = 0 ; senders[i].sender_id != 0; i++)
+ {
+ gibber_r_multicast_packet_add_sender_info (a,
+ senders[i].sender_id, senders[i].packet_id, NULL);
+ }
+
+ gibber_r_multicast_packet_add_payload (a, (guint8 *) payload,
+ strlen (payload));
+
+ data = gibber_r_multicast_packet_get_raw_data (a, &len);
+
+ b = gibber_r_multicast_packet_parse (data, len, NULL);
+ fail_unless (b != NULL);
+
+ COMPARE (type);
+ COMPARE (version);
+ COMPARE (data.data.flags);
+ COMPARE (data.data.total_size);
+ COMPARE (packet_id);
+ COMPARE (data.data.stream_id);
+
+ fail_unless (a->sender == b->sender);
+
+ for (n = 0 ; n < b->depends->len; n++)
+ {
+ for (i = 0; senders[i].sender_id != 0 ; i++)
+ {
+ GibberRMulticastPacketSenderInfo *s = g_array_index (b->depends,
+ GibberRMulticastPacketSenderInfo *, n);
+ if (senders[i].sender_id == s->sender_id)
+ {
+ fail_unless (senders[i].packet_id == s->packet_id);
+ fail_unless (senders[i].seen == FALSE);
+ senders[i].seen = TRUE;
+ break;
+ }
+ }
+
+ fail_unless (senders[i].sender_id != 0);
+ }
+
+ for (i = 0; senders[i].sender_id != 0 ; i++)
+ {
+ fail_unless (senders[i].seen == TRUE);
+ }
+
+
+ pdata = gibber_r_multicast_packet_get_payload (b, &plen);
+ fail_unless (plen == strlen (payload));
+
+ fail_unless (memcmp (payload, pdata, plen) == 0);
+
+ g_object_unref (a);
+ g_object_unref (b);
+} END_TEST
+
+START_TEST (test_attempt_join_packet)
+{
+ GibberRMulticastPacket *a;
+ GibberRMulticastPacket *b;
+ guint32 sender_id = 1234;
+ guint32 packet_id = 1200;
+ guint8 *data;
+ gsize len;
+ guint i, n;
+ sender_t senders[] =
+ { { 0x300, 500, FALSE }, { 0x400, 600, FALSE }, { 0, 0, FALSE } };
+ sender_t new_senders[] =
+ { { 0x500, 0, FALSE }, { 0x600, 0, FALSE }, { 0, 0, FALSE } };
+
+ g_type_init ();
+
+ a = gibber_r_multicast_packet_new (PACKET_TYPE_ATTEMPT_JOIN,
+ sender_id, 1500);
+ gibber_r_multicast_packet_set_packet_id (a, packet_id);
+
+ for (i = 0; senders[i].sender_id != 0; i++)
+ {
+ gibber_r_multicast_packet_add_sender_info (a,
+ senders[i].sender_id, senders[i].packet_id, NULL);
+ }
+ for (i = 0; new_senders[i].sender_id != 0; i++)
+ {
+ gibber_r_multicast_packet_attempt_join_add_sender (a,
+ new_senders[i].sender_id, NULL);
+ }
+
+ data = gibber_r_multicast_packet_get_raw_data (a, &len);
+
+ b = gibber_r_multicast_packet_parse (data, len, NULL);
+
+ fail_unless (b != NULL);
+
+ COMPARE (type);
+ COMPARE (version);
+ COMPARE (packet_id);
+ COMPARE (data.attempt_join.senders->len);
+
+ fail_unless (a->sender == b->sender);
+
+ for (n = 0; n < b->depends->len; n++)
+ {
+ for (i = 0; senders[i].sender_id != 0 ; i++)
+ {
+ GibberRMulticastPacketSenderInfo *s = g_array_index (b->depends,
+ GibberRMulticastPacketSenderInfo *, n);
+ if (senders[i].sender_id == s->sender_id)
+ {
+ fail_unless (senders[i].packet_id == s->packet_id);
+ fail_unless (senders[i].seen == FALSE);
+ senders[i].seen = TRUE;
+ break;
+ }
+ }
+
+ fail_unless (senders[i].sender_id != 0);
+ }
+
+ for (i = 0; senders[i].sender_id != 0; i++)
+ {
+ fail_unless (senders[i].seen == TRUE);
+ }
+
+ for (i = 0; new_senders[i].sender_id != 0; i++)
+ {
+ fail_unless (new_senders[i].sender_id ==
+ g_array_index (b->data.attempt_join.senders, guint32, i));
+ new_senders[i].seen = TRUE;
+ break;
+ }
+
+ for (i = 0; new_senders[i].sender_id != 0; i++)
+ {
+ fail_unless (senders[i].seen == TRUE);
+ }
+
+ g_object_unref (a);
+ g_object_unref (b);
+}
+END_TEST
+
+TCase *
+make_gibber_r_multicast_packet_tcase (void)
+{
+ TCase *tc = tcase_create ("RMulticast Packet");
+ tcase_add_test (tc, test_data_packet);
+ tcase_add_test (tc, test_attempt_join_packet);
+ tcase_add_loop_test (tc, test_r_multicast_packet_diff, 0,
+ NUMBER_OF_DIFF_TESTS);
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-r-multicast-sender.c b/lib/gibber/tests/check-gibber-r-multicast-sender.c
new file mode 100644
index 0000000..b0a4c90
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-r-multicast-sender.c
@@ -0,0 +1,652 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gibber/gibber-r-multicast-sender.h>
+
+#include <check.h>
+#include "check-gibber.h"
+
+#define SENDER 4321
+#define SENDER_NAME "testsender"
+
+#define REPAIR_PACKET ((guint32)15)
+
+#define EXTRA_SEEN ((guint32)11)
+#define NR_PACKETS ((guint32)40)
+
+guint32 serial_offset;
+guint32 expected;
+
+typedef struct {
+ guint32 serial_offset;
+ gboolean test_seen;
+} test_t;
+
+typedef struct {
+ guint32 receiver_id;
+ const gchar *name;
+ guint32 packet_id;
+} recv_t;
+
+GMainLoop *loop;
+recv_t receivers[] = {
+ { 0x500, "sender1", 500 },
+ { 0x600, "sender2", 600 },
+ { 0, NULL, 0 }
+};
+
+static GibberRMulticastPacket *
+generate_packet (guint32 serial)
+{
+ GibberRMulticastPacket *p;
+ guint8 flags = 0;
+ gint total = 1;
+ gchar *payload;
+ guint8 stream_id = 0;
+ int i;
+
+ switch (serial % 3)
+ {
+ case 0:
+ flags = GIBBER_R_MULTICAST_DATA_PACKET_START
+ | GIBBER_R_MULTICAST_DATA_PACKET_END;
+ stream_id = serial % G_MAXUINT8;
+ break;
+ case 1:
+ flags = GIBBER_R_MULTICAST_DATA_PACKET_START;
+ stream_id = serial % G_MAXUINT8;
+ total = 2;
+ break;
+ case 2:
+ flags = GIBBER_R_MULTICAST_DATA_PACKET_END;
+ stream_id = (serial - 1) % G_MAXUINT8;
+ total = 2;
+ break;
+ }
+
+ p = gibber_r_multicast_packet_new (PACKET_TYPE_DATA, SENDER, 1500);
+
+ gibber_r_multicast_packet_set_packet_id (p, serial);
+ gibber_r_multicast_packet_set_data_info (p, stream_id, flags, total * 11);
+
+ for (i = 0 ; receivers[i].receiver_id != 0; i++)
+ {
+ gibber_r_multicast_packet_add_sender_info (p,
+ receivers[i].receiver_id, receivers[i].packet_id, NULL);
+ }
+
+ payload = g_strdup_printf ("%010d\n", serial);
+ gibber_r_multicast_packet_add_payload (p, (guint8 *) payload,
+ strlen (payload));
+
+ g_free (payload);
+ return p;
+}
+
+static void
+data_received_cb (GibberRMulticastSender *sender, guint8 stream_id,
+ guint8 *data, gsize size, gpointer user_data)
+{
+ gchar *str;
+ gchar **lines;
+ int i;
+
+ str = g_strndup ((const gchar *)data, size);
+
+ lines = g_strsplit (str, "\n", 0);
+ for (i = 0 ; lines[i] != NULL && *lines[i] != '\0'; i++) {
+ guint32 v = atoi (lines[i]);
+
+ fail_unless (v == expected);
+ fail_unless ((v % G_MAXUINT8) - i == stream_id);
+ expected++;
+ }
+ /* serial % 3 is send out in a single packet the other two together.
+ * So expected can't be % 3 == 2 here */
+ fail_if (expected % 3 == 2);
+
+ if (expected == serial_offset + NR_PACKETS
+ || expected == serial_offset + NR_PACKETS + EXTRA_SEEN) {
+ g_main_loop_quit ((GMainLoop *) user_data);
+ }
+
+ g_strfreev (lines);
+ g_free (str);
+
+}
+
+static void
+repair_request_cb (GibberRMulticastSender *sender, guint id, gpointer data)
+{
+ GibberRMulticastPacket *p;
+
+ fail_unless (gibber_r_multicast_packet_diff (serial_offset, id) >= 0
+ || gibber_r_multicast_packet_diff (id,
+ serial_offset + NR_PACKETS + EXTRA_SEEN) < 0);
+
+ p = generate_packet (id);
+ gibber_r_multicast_sender_push (sender, p);
+ g_object_unref (p);
+}
+
+static void
+repair_message_cb (GibberRMulticastSender *sender,
+ GibberRMulticastPacket *packet, gpointer user_data)
+{
+
+ fail_unless (packet->type == PACKET_TYPE_DATA);
+ fail_unless (packet->packet_id == REPAIR_PACKET + serial_offset);
+
+ g_main_loop_quit ((GMainLoop *) user_data);
+}
+
+static gboolean
+add_packet (gpointer data)
+{
+ static guint32 i = 0;
+ GibberRMulticastSender *sender = GIBBER_R_MULTICAST_SENDER (data);
+ GibberRMulticastPacket *p;
+
+ if (i == NR_PACKETS)
+ {
+ i = 0;
+ return FALSE;
+ }
+
+ if (i % 5 != 3)
+ {
+ p = generate_packet (i + serial_offset);
+ gibber_r_multicast_sender_push (sender, p);
+ g_object_unref (p);
+ }
+
+ i++;
+ return TRUE;
+}
+
+
+#define NUMBER_OF_TESTS 3
+
+START_TEST (test_sender)
+{
+ GibberRMulticastSender *s;
+ GibberRMulticastSenderGroup *group;
+ test_t tests[NUMBER_OF_TESTS] = {
+ { (guint32)(~0 - NR_PACKETS/2), TRUE },
+ { 0xff, TRUE },
+ { 0xff, FALSE },
+ };
+ int i;
+
+ g_type_init ();
+ group = gibber_r_multicast_sender_group_new ();
+ loop = g_main_loop_new (NULL, FALSE);
+
+ serial_offset = tests[_i].serial_offset;
+ expected = serial_offset;
+
+ for (i = 0 ; receivers[i].receiver_id != 0; i++)
+ {
+ s = gibber_r_multicast_sender_new (receivers[i].receiver_id,
+ receivers[i].name, group);
+ gibber_r_multicast_sender_update_start (s, receivers[i].packet_id);
+ gibber_r_multicast_sender_seen (s, receivers[i].packet_id + 1);
+ gibber_r_multicast_sender_group_add (group, s);
+ }
+
+ s = gibber_r_multicast_sender_new (SENDER, SENDER_NAME, group);
+ g_signal_connect (s, "received-data", G_CALLBACK(data_received_cb), loop);
+ g_signal_connect (s, "repair-request", G_CALLBACK(repair_request_cb), loop);
+
+ gibber_r_multicast_sender_update_start (s, serial_offset);
+ gibber_r_multicast_sender_set_data_start (s, serial_offset);
+
+ if (tests[_i].test_seen)
+ {
+ gibber_r_multicast_sender_seen (s, serial_offset);
+ }
+ else
+ {
+ gibber_r_multicast_sender_repair_request (s, serial_offset);
+ }
+
+ g_timeout_add (10, add_packet, s);
+
+ g_main_loop_run (loop);
+
+ /* tell the sender we've seen some extra pakcets */
+ gibber_r_multicast_sender_seen (s, serial_offset + NR_PACKETS + EXTRA_SEEN);
+ g_main_loop_run (loop);
+
+ /* Ask for a repair */
+ g_signal_connect (s, "repair-message", G_CALLBACK (repair_message_cb), loop);
+
+ gibber_r_multicast_sender_repair_request (s, serial_offset + REPAIR_PACKET);
+
+ g_main_loop_run (loop);
+
+ gibber_r_multicast_sender_group_free (group);
+} END_TEST
+
+/* Holding test */
+guint32 idle_timer = 0;
+
+typedef struct {
+ gchar *name;
+ guint32 packet_id;
+ GibberRMulticastPacketType packet_type;
+ gchar *data;
+ gchar *depend_node;
+ guint32 depend_packet_id;
+ guint16 data_stream_id;
+ guint8 flags;
+ guint32 total_size;
+} h_setup_t;
+
+typedef enum {
+ EXPECT = 0,
+ START_DATA,
+ FAIL,
+ HOLD,
+ UNHOLD,
+ UNHOLD_IMMEDIATE,
+ DONE
+} h_expect_type_t;
+
+typedef struct {
+ h_expect_type_t type;
+ gchar *expected_node;
+ GibberRMulticastPacketType packet_type;
+ guint32 hold_id;
+ guint32 data_stream_id;
+} h_expect_t;
+
+typedef struct {
+ int test_step;
+ GibberRMulticastSenderGroup *group;
+ h_expect_t *expectation;
+} h_data_t;
+
+typedef struct {
+ h_setup_t *setup;
+ h_expect_t *expectation;
+} h_test_t;
+
+static void h_next_test_step (h_data_t *d);
+
+static gboolean
+h_find_sender (gpointer key, gpointer value, gpointer user_data)
+{
+ GibberRMulticastSender *s = GIBBER_R_MULTICAST_SENDER (value);
+
+ return strcmp (s->name, (gchar *) user_data) == 0;
+}
+
+static gboolean
+h_idle_next_step (gpointer user_data)
+{
+ h_data_t *d = (h_data_t *) user_data;
+ h_expect_t *e = &(d->expectation[d->test_step]);
+ GibberRMulticastSender *s;
+
+ idle_timer = 0;
+
+ switch (e->type) {
+ case UNHOLD_IMMEDIATE:
+ case START_DATA:
+ case FAIL:
+ case EXPECT:
+ fail ("Should not be reached");
+ break;
+ case HOLD:
+ s = g_hash_table_find (d->group->senders,
+ h_find_sender, e->expected_node);
+ fail_unless (s != NULL);
+ d->test_step++;
+ gibber_r_multicast_sender_hold_data (s, e->hold_id);
+ h_next_test_step (d);
+ break;
+ case UNHOLD:
+ s = g_hash_table_find (d->group->senders,
+ h_find_sender, e->expected_node);
+ fail_unless (s != NULL);
+ d->test_step++;
+ gibber_r_multicast_sender_release_data (s);
+ h_next_test_step (d);
+ break;
+ case DONE:
+ /* And there was great rejoice */
+ g_main_loop_quit (loop);
+ break;
+ }
+
+ return FALSE;
+}
+
+static void
+h_next_test_step (h_data_t *d)
+{
+ GibberRMulticastSender *s;
+ h_expect_t *e = &(d->expectation[d->test_step]);
+
+ switch (d->expectation[d->test_step].type) {
+ case EXPECT:
+ break;
+ case UNHOLD_IMMEDIATE:
+ s = g_hash_table_find (d->group->senders,
+ h_find_sender, e->expected_node);
+ fail_unless (s != NULL);
+ d->test_step++;
+ gibber_r_multicast_sender_release_data (s);
+ h_next_test_step (d);
+ break;
+ case START_DATA:
+ s = g_hash_table_find (d->group->senders,
+ h_find_sender, e->expected_node);
+ fail_unless (s != NULL);
+ d->test_step++;
+ gibber_r_multicast_sender_set_data_start (s, e->hold_id);
+ h_next_test_step (d);
+ break;
+ case FAIL:
+ s = g_hash_table_find (d->group->senders,
+ h_find_sender, e->expected_node);
+ fail_unless (s != NULL);
+ d->test_step++;
+ gibber_r_multicast_sender_set_failed (s);
+ h_next_test_step (d);
+ break;
+ case HOLD:
+ case UNHOLD:
+ case DONE:
+ if (idle_timer == 0)
+ {
+ idle_timer = g_idle_add (h_idle_next_step, d);
+ }
+ }
+}
+
+static void
+h_received_data_cb (GibberRMulticastSender *sender, guint16 stream_id,
+ guint8 *data, gsize size, gpointer user_data)
+{
+ h_data_t *d = (h_data_t *) user_data;
+
+ fail_unless (d->expectation[d->test_step].type == EXPECT);
+ fail_unless (d->expectation[d->test_step].packet_type == PACKET_TYPE_DATA);
+ fail_unless (
+ strcmp (d->expectation[d->test_step].expected_node, sender->name) == 0);
+ fail_unless (d->expectation[d->test_step].data_stream_id == stream_id);
+
+ d->test_step++;
+ h_next_test_step (d);
+}
+
+static void
+h_received_control_packet_cb (GibberRMulticastSender *sender,
+ GibberRMulticastPacket *packet, gpointer user_data)
+{
+ h_data_t *d = (h_data_t *) user_data;
+
+ fail_unless (d->expectation[d->test_step].type == EXPECT);
+ fail_unless (d->expectation[d->test_step].packet_type == packet->type);
+ fail_unless (
+ strcmp (d->expectation[d->test_step].expected_node, sender->name) == 0);
+
+ d->test_step++;
+ h_next_test_step (d);
+}
+
+h_setup_t h_setup0[] = {
+ { "node0", 0x1, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 3, 3 },
+ { "node1", 0x1, PACKET_TYPE_DATA, "001", "node0", 0x2, 0, 3, 3 },
+ { "node0", 0x2, PACKET_TYPE_DATA, "002", "node1", 0x2, 0, 3, 3 },
+ { "node1", 0x2, PACKET_TYPE_DATA, "002", "node0", 0x3, 0, 3, 3 },
+ { "node0", 0x3, PACKET_TYPE_ATTEMPT_JOIN, NULL, "node1", 0x3 },
+ { "node1", 0x3, PACKET_TYPE_ATTEMPT_JOIN, NULL, "node0", 0x4 },
+ { "node0", 0x4, PACKET_TYPE_DATA, "003", "node1", 0x4, 0, 3, 3 },
+ { "node1", 0x4, PACKET_TYPE_DATA, "003", "node0", 0x5, 0, 3, 3 },
+ { "node0", 0x5, PACKET_TYPE_JOIN, NULL, "node1", 0x5 },
+ { "node1", 0x5, PACKET_TYPE_JOIN, NULL, "node0", 0x6 },
+ { NULL },
+ };
+
+h_expect_t h_expectation0[] = {
+ { EXPECT, "node0", PACKET_TYPE_ATTEMPT_JOIN },
+ { EXPECT, "node1", PACKET_TYPE_ATTEMPT_JOIN },
+ { EXPECT, "node0", PACKET_TYPE_JOIN },
+ { EXPECT, "node1", PACKET_TYPE_JOIN },
+ /* Set the data start of node1 to 0x1, which means all the data should still
+ * be popped off */
+ { START_DATA, "node1", PACKET_TYPE_INVALID, 0x1 },
+ { START_DATA, "node0", PACKET_TYPE_INVALID, 0x1 },
+ /* only unhold node1, nothing should happen as they depend on those of
+ * node0 */
+ { HOLD, "node1", PACKET_TYPE_INVALID, 0x3 },
+ /* unhold node0 too, packets should start flowing */
+ { HOLD, "node0", PACKET_TYPE_INVALID, 0x3 },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 0 },
+ { EXPECT, "node1", PACKET_TYPE_DATA, 0, 0 },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 0 },
+ { EXPECT, "node1", PACKET_TYPE_DATA, 0, 0 },
+ { UNHOLD, "node1" },
+ { UNHOLD, "node0" },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 0 },
+ { EXPECT, "node1", PACKET_TYPE_DATA, 0, 0 },
+ { DONE },
+};
+
+h_setup_t h_setup1[] = {
+ { "node0", 0x1, PACKET_TYPE_ATTEMPT_JOIN, "001", "node1", 0x2 },
+ { "node1", 0x1, PACKET_TYPE_ATTEMPT_JOIN, "001", NULL },
+ { NULL },
+};
+
+h_expect_t h_expectation1[] = {
+ { EXPECT, "node1", PACKET_TYPE_ATTEMPT_JOIN },
+ { EXPECT, "node0", PACKET_TYPE_ATTEMPT_JOIN },
+ { DONE }
+};
+
+h_setup_t h_setup2[] = {
+ { "node0", 0x1, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 1, 9 },
+ { "node0", 0x3, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 0, 9 },
+ { "node0", 0x6, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 2, 9 },
+ { "node0", 0x2, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 1, 6 },
+ { "node0", 0x4, PACKET_TYPE_DATA, "001", NULL, 0x0, 2, 3, 3 },
+ { "node0", 0x5, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 2, 6 },
+ { NULL },
+};
+
+h_expect_t h_expectation2[] = {
+ { START_DATA, "node0", PACKET_TYPE_INVALID, 0x1 },
+ { UNHOLD, "node0" },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 2 },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 1 },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 0 },
+ { DONE }
+};
+
+h_setup_t h_setup3[] = {
+ { "node0", 0x1, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 1, 9 },
+ { "node0", 0x2, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 1, 6 },
+ { "node0", 0x3, PACKET_TYPE_ATTEMPT_JOIN, NULL, NULL },
+ { "node0", 0x4, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 0, 9 },
+ { "node0", 0x5, PACKET_TYPE_DATA, "001", NULL, 0x0, 2, 3, 3 },
+ { "node0", 0x6, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 2, 6 },
+ { "node0", 0x7, PACKET_TYPE_ATTEMPT_JOIN, NULL, NULL },
+ { "node0", 0x8, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 2, 9 },
+ { NULL },
+};
+
+h_expect_t h_expectation3[] = {
+ { EXPECT, "node0", PACKET_TYPE_ATTEMPT_JOIN },
+ { START_DATA, "node0", PACKET_TYPE_INVALID, 0x1 },
+ { UNHOLD_IMMEDIATE, "node0" },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 2 },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 1 },
+ { EXPECT, "node0", PACKET_TYPE_ATTEMPT_JOIN },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 0 },
+ { DONE }
+};
+
+h_setup_t h_setup4[] = {
+ { "node0", 0x1, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 1, 9 },
+ { "node0", 0x2, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 1, 6 },
+ { "node0", 0x3, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 0, 9 },
+ { "node0", 0x4, PACKET_TYPE_DATA, "001", NULL, 0x0, 2, 3, 3 },
+ { "node0", 0x5, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 2, 6 },
+ { "node0", 0x6, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 2, 9 },
+ { NULL },
+};
+
+h_expect_t h_expectation4[] = {
+ { START_DATA, "node0", PACKET_TYPE_INVALID, 0x2 },
+ { UNHOLD, "node0" },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 2 },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 1 },
+ { DONE }
+};
+
+/* Test if failing a node correctly pops the minimum amount of packets needed
+ * to fulfill all dependencies */
+h_setup_t h_setup5[] = {
+ { "node1", 0x1, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 3, 3 },
+ { "node1", 0x2, PACKET_TYPE_DATA, "001", "node0", 0x3, 2, 3, 3 },
+
+ /* As the very first thing do a Control packet, which isn't hold back. To
+ * force the setting of FAIL (as the setup instructions are run as soon as
+ * the join packet is received) */
+ { "node0", 0x1, PACKET_TYPE_JOIN, "001", NULL },
+ { "node0", 0x2, PACKET_TYPE_DATA, "001", "node1", 0x2, 2, 3, 3 },
+ { "node0", 0x3, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 3, 3 },
+ { NULL },
+};
+
+h_expect_t h_expectation5[] = {
+ { EXPECT, "node0", PACKET_TYPE_JOIN, 0, 1 },
+ { START_DATA, "node0", PACKET_TYPE_INVALID, 0x1 },
+ { START_DATA, "node1", PACKET_TYPE_INVALID, 0x1 },
+ { FAIL, "node0", PACKET_TYPE_INVALID, 0x2 },
+ { UNHOLD, "node0" },
+ { UNHOLD, "node1" },
+ { EXPECT, "node1", PACKET_TYPE_DATA, 0, 1 },
+ { EXPECT, "node0", PACKET_TYPE_DATA, 0, 2 },
+ { EXPECT, "node1", PACKET_TYPE_DATA, 0, 2 },
+ { DONE }
+};
+
+#define NUMBER_OF_H_TESTS 6
+h_test_t h_tests[NUMBER_OF_H_TESTS] = {
+ { h_setup0, h_expectation0 },
+ { h_setup1, h_expectation1 },
+ { h_setup2, h_expectation2 },
+ { h_setup3, h_expectation3 },
+ { h_setup4, h_expectation4 },
+ { h_setup5, h_expectation5 },
+ };
+
+
+static void
+add_h_sender (guint32 sender, gchar *name, GibberRMulticastSenderGroup *group,
+ guint32 packet_id, h_data_t *data)
+{
+ GibberRMulticastSender *s;
+
+ s = gibber_r_multicast_sender_new (sender, name, group);
+ gibber_r_multicast_sender_update_start (s, packet_id);
+ gibber_r_multicast_sender_hold_data (s, packet_id);
+ gibber_r_multicast_sender_group_add (group, s);
+
+ g_signal_connect (s, "received-data",
+ G_CALLBACK (h_received_data_cb), data);
+ g_signal_connect (s, "received-control-packet",
+ G_CALLBACK (h_received_control_packet_cb), data);
+}
+
+START_TEST (test_holding) {
+ GibberRMulticastSenderGroup *group;
+ guint32 sender_offset = 0xf00;
+ /* control packets aren't hold back, thus we get them interleaved at first
+ */
+ h_test_t *test = h_tests + _i;
+ h_data_t data = { 0, NULL, test->expectation };
+ int i;
+
+ g_type_init ();
+ loop = g_main_loop_new (NULL, FALSE);
+
+ group = gibber_r_multicast_sender_group_new ();
+ data.group = group;
+
+ for (i = 0; test->setup[i].name != NULL; i++)
+ {
+ GibberRMulticastSender *s;
+ s = g_hash_table_find (group->senders,
+ h_find_sender, test->setup[i].name);
+ if (s == NULL)
+ {
+ add_h_sender (sender_offset++, test->setup[i].name, group,
+ test->setup[i].packet_id, &data);
+ }
+ }
+
+ for (i = 0; test->setup[i].name != NULL; i++)
+ {
+ GibberRMulticastSender *s0, *s1 = NULL;
+ GibberRMulticastPacket *p;
+
+ s0 = g_hash_table_find (group->senders, h_find_sender,
+ test->setup[i].name);
+ fail_unless (s0 != NULL);
+
+ p = gibber_r_multicast_packet_new (test->setup[i].packet_type, s0->id,
+ 1500);
+ gibber_r_multicast_packet_set_packet_id (p, test->setup[i].packet_id);
+
+ if (test->setup[i].depend_node != NULL)
+ {
+ s1 = g_hash_table_find (group->senders, h_find_sender,
+ test->setup[i].depend_node);
+ fail_unless (s1 != NULL);
+ fail_unless (gibber_r_multicast_packet_add_sender_info (p, s1->id,
+ test->setup[i].depend_packet_id, NULL));
+ }
+ if (test->setup[i].packet_type == PACKET_TYPE_DATA)
+ {
+ fail_unless (test->setup[i].data != NULL);
+
+ gibber_r_multicast_packet_set_data_info (p,
+ test->setup[i].data_stream_id,
+ test->setup[i].flags,
+ test->setup[i].total_size);
+ gibber_r_multicast_packet_add_payload (p,
+ (guint8 *) test->setup[i].data, strlen (test->setup[i].data));
+ }
+ gibber_r_multicast_sender_push (s0, p);
+
+ g_object_unref (p);
+ }
+
+ h_next_test_step (&data);
+
+ do
+ {
+ g_main_loop_run (loop);
+ }
+ while (data.expectation[data.test_step].type != DONE);
+
+ fail_unless (idle_timer == 0);
+
+} END_TEST
+
+TCase *
+make_gibber_r_multicast_sender_tcase (void)
+{
+ TCase *tc = tcase_create ("RMulticast Sender");
+ tcase_set_timeout (tc, 20);
+ tcase_add_loop_test (tc, test_sender, 0, NUMBER_OF_TESTS);
+ tcase_add_loop_test (tc, test_holding, 0, NUMBER_OF_H_TESTS );
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-resolver.c b/lib/gibber/tests/check-gibber-resolver.c
new file mode 100644
index 0000000..ba6effa
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-resolver.c
@@ -0,0 +1,91 @@
+/*
+ * check-gibber-resolver.c - Test for gibber-resolver functions
+ * Copyright (C) 2008 Collabora Ltd.
+ * @author Sjoerd Simons <sjoerd.simons at collabora.co.uk>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "test-resolver.h"
+#include "check-gibber.h"
+
+#include <check.h>
+
+GMainLoop *mainloop = NULL;
+gboolean done = FALSE;
+
+static void
+resolver_srv_cb (GibberResolver *resolver, GList *srv_list, GError *error,
+ gpointer user_data, GObject *weak_object)
+{
+ GList *s;
+ int last_prio = 0;
+ int last_weight = 0;
+
+ for (s = srv_list ; s != NULL; s = g_list_next (s))
+ {
+ GibberResolverSrvRecord *r = (GibberResolverSrvRecord *) s->data;
+
+ fail_unless (last_prio <= r->priority);
+
+ if (last_prio != r->priority)
+ last_weight = 0;
+
+ /* If our previous weight was non-zero, then this one has to be non-zero
+ * too. The SRV RFC requires all entries with zero weight to be sorted
+ * before all other entries with the same priority */
+ fail_unless (last_weight == 0 || r->weight != 0);
+
+ last_prio = r->priority;
+ last_weight = r->weight;
+ }
+
+ done = TRUE;
+
+ if (g_main_loop_is_running (mainloop))
+ g_main_loop_quit (mainloop);
+}
+
+START_TEST (test_srv_resolving)
+{
+ GibberResolver *resolver;
+
+ done = FALSE;
+ mainloop = g_main_loop_new (NULL, FALSE);
+
+ resolver = g_object_new (TEST_TYPE_RESOLVER, NULL);
+
+ gibber_resolver_srv (resolver, "test", "test",
+ GIBBER_RESOLVER_SERVICE_TYPE_TCP,
+ resolver_srv_cb, NULL, NULL, NULL);
+
+ if (!done)
+ g_main_loop_run (mainloop);
+
+ g_main_loop_unref (mainloop);
+} END_TEST
+
+TCase *
+make_gibber_resolver_tcase (void)
+{
+ TCase *tc = tcase_create ("Resolve");
+ tcase_add_test (tc, test_srv_resolving);
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-sasl-auth.c b/lib/gibber/tests/check-gibber-sasl-auth.c
new file mode 100644
index 0000000..4ce68ff
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-sasl-auth.c
@@ -0,0 +1,213 @@
+#include <stdio.h>
+
+#include "test-sasl-auth-server.h"
+#include "test-transport.h"
+#include <gibber/gibber-xmpp-connection.h>
+#include <gibber/gibber-sasl-auth.h>
+
+#include <check.h>
+#include "check-gibber.h"
+
+typedef struct {
+ gchar *description;
+ gchar *mech;
+ gboolean allow_plain;
+ GQuark domain;
+ int code;
+ ServerProblem problem;
+} test_t;
+
+GMainLoop *mainloop;
+GibberTransport *servertransport;
+GibberTransport *clienttransport;
+GibberXmppConnection *conn;
+GibberSaslAuth *sasl = NULL;
+
+const gchar *username = "test";
+const gchar *password = "test123";
+const gchar *servername = "testserver";
+
+gboolean authenticated = FALSE;
+gboolean run_done = FALSE;
+
+test_t *current_test = NULL;
+GError *error = NULL;
+
+static void
+got_error (GQuark domain, int code, const gchar *message)
+{
+ g_set_error (&error, domain, code, "%s", message);
+ run_done = TRUE;
+ g_main_loop_quit (mainloop);
+}
+
+static gboolean
+send_hook (GibberTransport *transport, const guint8 *data,
+ gsize length, GError **err, gpointer user_data)
+{
+ GibberTransport *target =
+ (servertransport == transport) ? clienttransport : servertransport;
+
+ test_transport_write (TEST_TRANSPORT (target), data, length);
+ return TRUE;
+}
+
+static gchar *
+return_str (GibberSaslAuth *auth, gpointer user_data)
+{
+ return g_strdup (user_data);
+}
+
+static void
+auth_success (GibberSaslAuth *sasl_, gpointer user_data)
+{
+ authenticated = TRUE;
+ /* Reopen the connection */
+ gibber_xmpp_connection_restart (conn);
+ gibber_xmpp_connection_open (conn, servername, NULL, "1.0");
+}
+
+static void
+auth_failed (GibberSaslAuth *sasl_, GQuark domain,
+ int code, gchar *message, gpointer user_data)
+{
+ got_error (domain, code, message);
+}
+
+static void
+parse_error (GibberXmppConnection *connection, gpointer user_data)
+{
+ fail ();
+}
+
+static void
+stream_opened (GibberXmppConnection *connection,
+ gchar *from, gchar *to, gchar *version, gpointer user_data)
+{
+ if (authenticated)
+ gibber_xmpp_connection_close (conn);
+}
+
+static void
+stream_closed (GibberXmppConnection *connection, gpointer user_data)
+{
+ run_done = TRUE;
+ g_main_loop_quit (mainloop);
+}
+
+static void
+received_stanza (GibberXmppConnection *connection, GibberXmppStanza *stanza,
+ gpointer user_data)
+{
+ if (sasl == NULL)
+ {
+ GError *err = NULL;
+ sasl = gibber_sasl_auth_new ();
+
+ g_signal_connect (sasl, "username-requested",
+ G_CALLBACK (return_str), (gpointer)username);
+ g_signal_connect (sasl, "password-requested",
+ G_CALLBACK (return_str), (gpointer)password);
+ g_signal_connect (sasl, "authentication-succeeded",
+ G_CALLBACK (auth_success), NULL);
+ g_signal_connect (sasl, "authentication-failed",
+ G_CALLBACK (auth_failed), NULL);
+
+ if (!gibber_sasl_auth_authenticate (sasl, servername, connection, stanza,
+ current_test->allow_plain, &err))
+ {
+ got_error (err->domain, err->code, err->message);
+ g_error_free (err);
+ }
+ }
+}
+
+static void
+run_rest (test_t *test)
+{
+ TestSaslAuthServer *server;
+
+ servertransport = GIBBER_TRANSPORT(test_transport_new (send_hook, NULL));
+
+ server = test_sasl_auth_server_new (servertransport, test->mech, username,
+ password, test->problem);
+
+ authenticated = FALSE;
+ run_done = FALSE;
+ current_test = test;
+
+ clienttransport = GIBBER_TRANSPORT (test_transport_new (send_hook, NULL));
+ conn = gibber_xmpp_connection_new (clienttransport);
+
+ g_signal_connect (conn, "parse-error", G_CALLBACK (parse_error), NULL);
+ g_signal_connect (conn, "stream-opened", G_CALLBACK (stream_opened), NULL);
+ g_signal_connect (conn, "stream-closed", G_CALLBACK (stream_closed), NULL);
+ g_signal_connect (conn, "received-stanza",
+ G_CALLBACK (received_stanza), NULL);
+ gibber_xmpp_connection_open (conn, servername, NULL, "1.0");
+
+ if (!run_done)
+ {
+ g_main_loop_run (mainloop);
+ }
+
+ if (sasl != NULL)
+ {
+ g_object_unref (sasl);
+ sasl = NULL;
+ }
+
+ g_object_unref (servertransport);
+ g_object_unref (clienttransport);
+ g_object_unref (conn);
+
+ fail_if (test->domain == 0 && error != NULL);
+ fail_if (test->domain != 0 && error == NULL);
+
+ if (error != NULL)
+ {
+ fail_if (test->domain != error->domain);
+ fail_if (test->code != error->code);
+ }
+
+ if (error != NULL)
+ g_error_free (error);
+
+ error = NULL;
+}
+
+#define SUCCESS(desc, mech, allow_plain) \
+ { desc, mech, allow_plain, 0, 0, SERVER_PROBLEM_NO_PROBLEM }
+
+#define NUMBER_OF_TEST 6
+
+START_TEST (test_auth)
+{
+ test_t tests[NUMBER_OF_TEST] = {
+ SUCCESS("Normal authentication", NULL, TRUE),
+ SUCCESS("Disallow PLAIN", "PLAIN", TRUE),
+ SUCCESS("Plain method authentication", "PLAIN", TRUE),
+ SUCCESS("Normal DIGEST-MD5 authentication", "DIGEST-MD5", TRUE),
+
+ { "No supported mechanisms", "NONSENSE", TRUE,
+ GIBBER_SASL_AUTH_ERROR, GIBBER_SASL_AUTH_ERROR_NO_SUPPORTED_MECHANISMS,
+ SERVER_PROBLEM_NO_PROBLEM },
+ { "No sasl support in server", NULL, TRUE,
+ GIBBER_SASL_AUTH_ERROR, GIBBER_SASL_AUTH_ERROR_SASL_NOT_SUPPORTED,
+ SERVER_PROBLEM_NO_SASL },
+ };
+
+ g_type_init ();
+
+ mainloop = g_main_loop_new (NULL, FALSE);
+
+ run_rest (&(tests[_i]));
+} END_TEST
+
+TCase *
+make_gibber_sasl_auth_tcase (void)
+{
+ TCase *tc = tcase_create ("SASL Auth");
+ tcase_add_loop_test (tc, test_auth, 0, NUMBER_OF_TEST);
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-xmpp-connection-listener.c b/lib/gibber/tests/check-gibber-xmpp-connection-listener.c
new file mode 100644
index 0000000..8dd1931
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-xmpp-connection-listener.c
@@ -0,0 +1,120 @@
+/*
+ * check-gibber-xmpp-connection-listener.c - Test for
+ * GibberXmppConnectionListener
+ * Copyright (C) 2007 Collabora Ltd.
+ * @author Guillaume Desmottes <guillaume.desmottes at collabora.co.uk>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <gibber/gibber-linklocal-transport.h>
+#include <gibber/gibber-listener.h>
+#include <gibber/gibber-xmpp-connection.h>
+#include <gibber/gibber-xmpp-connection-listener.h>
+
+#include <check.h>
+#include "check-gibber.h"
+
+gboolean got_connection;
+
+static void
+new_connection_cb (GibberXmppConnectionListener *listener,
+ GibberXmppConnection *connection,
+ struct sockaddr *addr,
+ guint size,
+ gpointer user_data)
+{
+ got_connection = TRUE;
+}
+
+static gboolean
+connect_to_port (int port)
+{
+ GibberLLTransport *transport;
+ struct sockaddr_in addr;
+ gboolean result;
+
+ transport = gibber_ll_transport_new ();
+
+ memset (&addr, 0, sizeof (addr));
+ addr.sin_family = AF_INET;
+ addr.sin_port = htons (port);
+ addr.sin_addr.s_addr = inet_addr ("127.0.0.1");
+
+ result = gibber_ll_transport_open_sockaddr (transport,
+ (struct sockaddr_storage *) &addr, NULL);
+
+ g_object_unref (transport);
+ return result;
+}
+
+START_TEST (test_listen)
+{
+ GibberXmppConnectionListener *listener;
+ int port;
+ gboolean result;
+
+ got_connection = FALSE;
+
+ listener = gibber_xmpp_connection_listener_new ();
+ fail_if (listener == NULL);
+
+ g_signal_connect (listener, "new-connection", G_CALLBACK (new_connection_cb),
+ NULL);
+
+ for (port = 5298; port < 5400; port++)
+ {
+ GError *error = NULL;
+ if (gibber_xmpp_connection_listener_listen (listener, port, &error))
+ break;
+
+ fail_if (!g_error_matches (error, GIBBER_LISTENER_ERROR,
+ GIBBER_LISTENER_ERROR_ADDRESS_IN_USE));
+ g_error_free (error);
+ error = NULL;
+ }
+ fail_if (port >= 5400);
+
+ result = connect_to_port (port);
+ fail_if (result == FALSE);
+
+ while (g_main_context_iteration (NULL, FALSE))
+ ;
+ fail_if (got_connection == FALSE);
+
+ g_object_unref (listener);
+
+ /* listener is destroyed, connection should be refused now */
+ got_connection = FALSE;
+ result = connect_to_port (port);
+ fail_if (result == TRUE);
+} END_TEST
+
+TCase *
+make_gibber_xmpp_connection_listener_tcase (void)
+{
+ TCase *tc = tcase_create ("GibberXmppConnectionListener");
+ tcase_add_test (tc, test_listen);
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-xmpp-connection.c b/lib/gibber/tests/check-gibber-xmpp-connection.c
new file mode 100644
index 0000000..de9dd1d
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-xmpp-connection.c
@@ -0,0 +1,126 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <glib.h>
+
+#include <gibber/gibber-xmpp-connection.h>
+#include <gibber/gibber-transport.h>
+#include "test-transport.h"
+#include "check-gibber.h"
+
+#include <check.h>
+
+struct _FileChunker {
+ gchar *contents;
+ gsize length;
+ gsize size;
+ gsize offset;
+};
+typedef struct _FileChunker FileChunker;
+
+static void
+file_chunker_destroy (FileChunker *fc) {
+ g_free (fc->contents);
+ g_free (fc);
+}
+
+
+static FileChunker *
+file_chunker_new (const gchar *filename, gsize chunk_size) {
+ FileChunker *fc;
+ fc = g_new0 (FileChunker, 1);
+
+ fc->size = chunk_size;
+ if (!g_file_get_contents (filename, &fc->contents, &fc->length, NULL)) {
+ file_chunker_destroy (fc);
+ return NULL;
+ }
+ return fc;
+}
+
+static gboolean
+file_chunker_get_chunk (FileChunker *fc,
+ gchar **chunk,
+ gsize *chunk_size) {
+ if (fc->offset < fc->length) {
+ *chunk_size = MIN (fc->length - fc->offset, fc->size);
+ *chunk = fc->contents + fc->offset;
+ fc->offset += *chunk_size;
+ return TRUE;
+ }
+ return FALSE;
+}
+
+
+START_TEST (test_instantiation)
+{
+ GibberXmppConnection *connection;
+ TestTransport *transport;
+
+ transport = test_transport_new (NULL, NULL);
+ connection = gibber_xmpp_connection_new (GIBBER_TRANSPORT(transport));
+
+ fail_if (connection == NULL);
+
+ connection = gibber_xmpp_connection_new (NULL);
+
+ fail_if (connection == NULL);
+}
+END_TEST
+
+static void
+parse_error_cb (GibberXmppConnection *connection, gpointer user_data)
+{
+ gboolean *parse_error_found = user_data;
+ *parse_error_found = TRUE;
+}
+
+START_TEST (test_simple_message)
+{
+ GibberXmppConnection *connection;
+ TestTransport *transport;
+ gchar *chunk;
+ gsize chunk_length;
+ gboolean parse_error_found = FALSE;
+ const gchar *srcdir;
+ gchar *file;
+ FileChunker *fc;
+
+ srcdir = g_getenv ("srcdir");
+ if (srcdir == NULL)
+ {
+ file = g_strdup ("inputs/simple-message.input");
+ }
+ else
+ {
+ file = g_strdup_printf ("%s/inputs/simple-message.input", srcdir);
+ }
+
+ fc = file_chunker_new (file, 10);
+ fail_if (fc == NULL);
+
+ transport = test_transport_new (NULL, NULL);
+ connection = gibber_xmpp_connection_new (GIBBER_TRANSPORT(transport));
+
+ g_signal_connect (connection, "parse-error",
+ G_CALLBACK(parse_error_cb), &parse_error_found);
+
+ while (!parse_error_found &&
+ file_chunker_get_chunk (fc, &chunk, &chunk_length))
+ {
+ test_transport_write (transport, (guint8 *) chunk, chunk_length);
+ }
+
+ fail_if (parse_error_found);
+
+ g_free (file);
+ file_chunker_destroy (fc);
+} END_TEST
+
+TCase *
+make_gibber_xmpp_connection_tcase (void)
+{
+ TCase *tc = tcase_create ("XMPP Connection");
+ tcase_add_test (tc, test_instantiation);
+ tcase_add_test (tc, test_simple_message);
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-xmpp-error.c b/lib/gibber/tests/check-gibber-xmpp-error.c
new file mode 100644
index 0000000..3acc61c
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-xmpp-error.c
@@ -0,0 +1,139 @@
+/*
+ * check-gibber-xmpp-error.c - Test for gibber-xmpp-error functions
+ * Copyright (C) 2007 Collabora Ltd.
+ * @author Guillaume Desmottes <guillaume.desmottes at collabora.co.uk>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gibber/gibber-xmpp-error.h>
+
+#define DEBUG_FLAG DEBUG_XMPP
+#include <gibber/gibber-debug.h>
+
+#include <check.h>
+#include "check-gibber.h"
+
+static void
+test_xmpp_error_to_node_with_bad_request (void)
+{
+ GibberXmppStanza *stanza;
+ GibberXmppNode *node;
+ const gchar *code;
+ const gchar *type;
+
+ stanza = gibber_xmpp_stanza_build (
+ GIBBER_STANZA_TYPE_IQ, GIBBER_STANZA_SUB_TYPE_ERROR,
+ "from", "to",
+ GIBBER_STANZA_END);
+ node = gibber_xmpp_error_to_node (XMPP_ERROR_BAD_REQUEST, stanza->node,
+ NULL);
+
+ fail_if (node == NULL);
+ fail_if (strcmp (node->name, "error") != 0);
+
+ code = gibber_xmpp_node_get_attribute (node, "code");
+ fail_if (code == NULL || strcmp (code, "400") != 0);
+
+ type = gibber_xmpp_node_get_attribute (node, "type");
+ fail_if (type == NULL || strcmp (type, "modify") != 0);
+
+ fail_if (gibber_xmpp_node_get_child_ns (node, "bad-request",
+ "urn:ietf:params:xml:ns:xmpp-stanzas") == NULL);
+
+ g_object_unref (stanza);
+}
+
+static void
+test_xmpp_error_to_node_with_si_bad_profile (void)
+{
+ GibberXmppStanza *stanza;
+ GibberXmppNode *node;
+ const gchar *code;
+ const gchar *type;
+
+ stanza = gibber_xmpp_stanza_build (
+ GIBBER_STANZA_TYPE_IQ, GIBBER_STANZA_SUB_TYPE_ERROR,
+ "from", "to",
+ GIBBER_STANZA_END);
+ node = gibber_xmpp_error_to_node (XMPP_ERROR_SI_BAD_PROFILE, stanza->node,
+ NULL);
+
+ fail_if (node == NULL);
+ fail_if (strcmp (node->name, "error") != 0);
+
+ code = gibber_xmpp_node_get_attribute (node, "code");
+ fail_if (code == NULL || strcmp (code, "400") != 0);
+
+ type = gibber_xmpp_node_get_attribute (node, "type");
+ fail_if (type == NULL || strcmp (type, "modify") != 0);
+
+ fail_if (gibber_xmpp_node_get_child_ns (node, "bad-request",
+ "urn:ietf:params:xml:ns:xmpp-stanzas") == NULL);
+
+ fail_if (gibber_xmpp_node_get_child_ns (node, "bad-profile",
+ "http://jabber.org/protocol/si") == NULL);
+
+ g_object_unref (stanza);
+}
+
+START_TEST (test_xmpp_error_to_node)
+{
+ test_xmpp_error_to_node_with_bad_request ();
+ test_xmpp_error_to_node_with_si_bad_profile ();
+} END_TEST
+
+START_TEST (test_message_get_xmpp_error)
+{
+ GibberXmppError xmpp_error;
+
+ for (xmpp_error = 1; xmpp_error < NUM_XMPP_ERRORS; xmpp_error++)
+ {
+ GibberXmppStanza *stanza;
+ GError *error = NULL;
+
+ stanza = gibber_xmpp_stanza_build (
+ GIBBER_STANZA_TYPE_IQ, GIBBER_STANZA_SUB_TYPE_ERROR,
+ "from", "to",
+ GIBBER_STANZA_END);
+ gibber_xmpp_error_to_node (xmpp_error, stanza->node, NULL);
+
+ error = gibber_message_get_xmpp_error (stanza);
+ fail_if (error == NULL);
+
+ fail_if (error->domain != GIBBER_XMPP_ERROR);
+ fail_if (error->code != (gint) xmpp_error);
+ fail_if (strcmp (error->message, gibber_xmpp_error_description (
+ xmpp_error)) != 0);
+
+ g_object_unref (stanza);
+ g_error_free (error);
+ }
+
+} END_TEST
+
+TCase *
+make_gibber_xmpp_error_tcase (void)
+{
+ TCase *tc = tcase_create ("XMPP Error");
+ tcase_add_test (tc, test_xmpp_error_to_node);
+ tcase_add_test (tc, test_message_get_xmpp_error);
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-xmpp-node.c b/lib/gibber/tests/check-gibber-xmpp-node.c
new file mode 100644
index 0000000..3f5ea32
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-xmpp-node.c
@@ -0,0 +1,167 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <gibber/gibber-xmpp-node.h>
+
+#include <check.h>
+#include "check-helpers.h"
+#include "check-gibber.h"
+
+START_TEST (test_instantiation)
+{
+ GibberXmppNode *node;
+ node = gibber_xmpp_node_new ("test");
+ fail_unless (node != NULL);
+
+ gibber_xmpp_node_free (node);
+
+ node = gibber_xmpp_node_new (NULL);
+ fail_unless (node != NULL);
+
+ gibber_xmpp_node_free (node);
+}
+END_TEST
+
+START_TEST (test_language)
+{
+ GibberXmppNode *node;
+ const gchar *lang;
+
+ /* Unit test are not examples of how to use an API! Don't rely on the
+ * following in your applications! (or better yet, don't give invalid input)
+ * */
+ fail_unless_critical (lang = gibber_xmpp_node_get_language (NULL));
+ fail_unless (lang == NULL);
+
+ node = gibber_xmpp_node_new ("test");
+ lang = gibber_xmpp_node_get_language (node);
+ fail_unless (lang == NULL);
+
+ gibber_xmpp_node_set_language (node, "en");
+ lang = gibber_xmpp_node_get_language (node);
+ fail_unless (strcmp (lang, "en") == 0);
+
+ gibber_xmpp_node_set_language (node, NULL);
+ lang = gibber_xmpp_node_get_language (node);
+ fail_unless (lang == NULL);
+
+ gibber_xmpp_node_set_language_n (node, "en-US", 2);
+ lang = gibber_xmpp_node_get_language (node);
+ fail_unless (strcmp (lang, "en") == 0);
+
+ gibber_xmpp_node_set_language_n (node, NULL, 2);
+ lang = gibber_xmpp_node_get_language (node);
+ fail_unless (lang == NULL);
+
+ gibber_xmpp_node_free (node);
+}
+END_TEST
+
+START_TEST (test_namespace)
+{
+ GibberXmppNode *node;
+ const gchar *ns;
+
+ node = gibber_xmpp_node_new ("test");
+
+ ns = gibber_xmpp_node_get_ns (node);
+ fail_unless (ns == NULL);
+
+ gibber_xmpp_node_set_ns (node, "foo");
+ ns = gibber_xmpp_node_get_ns (node);
+ fail_unless (strcmp (ns, "foo") == 0);
+
+ gibber_xmpp_node_set_ns (node, NULL);
+ ns = gibber_xmpp_node_get_ns (node);
+ fail_unless (ns == NULL);
+
+ gibber_xmpp_node_free (node);
+}
+END_TEST
+
+
+START_TEST (test_attribute)
+{
+ GibberXmppNode *node;
+ const gchar *attribute;
+
+ node = gibber_xmpp_node_new ("test");
+
+ attribute = gibber_xmpp_node_get_attribute (node, "foo");
+ fail_unless (attribute == NULL);
+
+ attribute = gibber_xmpp_node_get_attribute (node, NULL);
+ fail_unless (attribute == NULL);
+
+ attribute = gibber_xmpp_node_get_attribute_ns (node, "foo", "bar");
+ fail_unless (attribute == NULL);
+
+ gibber_xmpp_node_set_attribute (node, "foo", "baz");
+
+ attribute = gibber_xmpp_node_get_attribute (node, "foo");
+ fail_unless (strcmp ( attribute, "baz") == 0);
+
+ attribute = gibber_xmpp_node_get_attribute_ns (node, "foo", "bar");
+ fail_unless (attribute == NULL);
+
+ gibber_xmpp_node_set_attribute_ns (node, "foobar", "barbaz", "bar");
+
+ attribute = gibber_xmpp_node_get_attribute (node, "foobar");
+ fail_unless (strcmp (attribute, "barbaz") == 0);
+
+ attribute = gibber_xmpp_node_get_attribute_ns (node, "foobar", "bar");
+ fail_unless (strcmp (attribute, "barbaz") == 0);
+
+ attribute = gibber_xmpp_node_get_attribute_ns (node, "barfoo", "bar");
+ fail_unless (attribute == NULL);
+
+ gibber_xmpp_node_free (node);
+}
+END_TEST
+
+START_TEST (test_child)
+{
+ GibberXmppNode *node, *child;
+
+ node = gibber_xmpp_node_new ("test");
+
+ child = gibber_xmpp_node_get_child (node, "foo");
+ fail_unless (child == NULL);
+
+ gibber_xmpp_node_add_child (node, "foo");
+ child = gibber_xmpp_node_get_child (node, "foo");
+ fail_if (child == NULL);
+ fail_unless (strcmp (child->name, "foo") == 0);
+
+ child = gibber_xmpp_node_get_child_ns (node, "foo", "bar");
+ fail_unless (child == NULL);
+
+ gibber_xmpp_node_add_child_ns (node, "foobar", "bar");
+ child = gibber_xmpp_node_get_child_ns (node, "foobar", "foo");
+ fail_unless (child == NULL);
+ child = gibber_xmpp_node_get_child_ns (node, "foobar", "bar");
+ fail_if (child == NULL);
+ fail_unless (strcmp (child->name, "foobar") == 0);
+
+ gibber_xmpp_node_add_child_with_content (node, "foo2", "blah");
+ child = gibber_xmpp_node_get_child (node, "foo2");
+ fail_if (child->content == NULL);
+ fail_unless (strcmp (child->content, "blah") == 0);
+
+ gibber_xmpp_node_free (node);
+}
+END_TEST
+
+
+TCase *
+make_gibber_xmpp_node_tcase (void)
+{
+ TCase *tc = tcase_create ("XMPP Node");
+ tcase_add_test (tc, test_instantiation);
+ tcase_add_test (tc, test_language);
+ tcase_add_test (tc, test_namespace);
+ tcase_add_test (tc, test_attribute);
+ tcase_add_test (tc, test_child);
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-xmpp-reader.c b/lib/gibber/tests/check-gibber-xmpp-reader.c
new file mode 100644
index 0000000..d6bb8b0
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-xmpp-reader.c
@@ -0,0 +1,127 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <gibber/gibber-xmpp-reader.h>
+#include <gibber/gibber-xmpp-stanza.h>
+
+#include <check.h>
+
+#include "check-gibber.h"
+
+typedef struct _ReceivedStanzaEvent ReceivedStanzaEvent;
+
+struct _ReceivedStanzaEvent {
+ GibberXmppReader *reader;
+ GibberXmppStanza *stanza;
+};
+
+static void received_stanza_cb (GibberXmppReader *reader,
+ GibberXmppStanza *stanza, gpointer user_data)
+{
+ GQueue *events_queue = (GQueue *) user_data;
+ ReceivedStanzaEvent *event;
+
+ fail_if (reader == NULL);
+ fail_if (stanza == NULL);
+ fail_if (events_queue == NULL);
+
+ g_object_ref (stanza);
+
+ event = g_new (ReceivedStanzaEvent, 1);
+ event->reader = reader;
+ event->stanza = stanza;
+
+ g_queue_push_tail (events_queue, event);
+}
+
+
+START_TEST (test_instantiation)
+{
+ GibberXmppReader *reader;
+ reader = gibber_xmpp_reader_new_no_stream ();
+ fail_if (reader == NULL);
+ g_object_unref (reader);
+}
+END_TEST
+
+START_TEST (test_simple_message)
+{
+ GibberXmppReader *reader;
+ GibberXmppNode *node;
+ gchar *data;
+ gsize length;
+ gboolean valid;
+ GQueue *received_stanzas;
+ ReceivedStanzaEvent *event;
+ const gchar *srcdir;
+ gchar *file;
+
+ received_stanzas = g_queue_new ();
+
+ reader = gibber_xmpp_reader_new ();
+ g_signal_connect (reader, "received-stanza",
+ G_CALLBACK (received_stanza_cb), received_stanzas);
+
+ srcdir = g_getenv ("srcdir");
+ if (srcdir == NULL)
+ {
+ file = g_strdup ("inputs/simple-message.input");
+ }
+ else
+ {
+ file = g_strdup_printf ("%s/inputs/simple-message.input", srcdir);
+ }
+
+ fail_unless (g_file_get_contents (file, &data, &length, NULL));
+ g_free (file);
+
+ valid = gibber_xmpp_reader_push (reader, (guint8 *) data, length, NULL);
+ fail_unless (valid);
+
+ fail_unless (g_queue_get_length (received_stanzas) == 2);
+
+ event = g_queue_pop_head (received_stanzas);
+
+ fail_unless (event->reader == reader);
+
+ node = event->stanza->node;
+ fail_if (node == NULL);
+ fail_unless (strcmp (node->name, "message") == 0);
+ fail_unless (strcmp (gibber_xmpp_node_get_language (node), "en") == 0);
+ fail_unless (strcmp (gibber_xmpp_node_get_attribute (node, "to"),
+ "juliet at example.com") == 0);
+ fail_unless (strcmp (gibber_xmpp_node_get_attribute (node, "id"),
+ "0") == 0);
+
+ g_object_unref (event->stanza);
+ g_free (event);
+
+ event = g_queue_pop_head (received_stanzas);
+
+ fail_unless (event->reader == reader);
+
+ node = event->stanza->node;
+ fail_unless (strcmp (node->name, "message") == 0);
+ fail_unless (strcmp (gibber_xmpp_node_get_language (node), "en") == 0);
+ fail_unless (strcmp (gibber_xmpp_node_get_attribute (node, "to"),
+ "juliet at example.com") == 0);
+ fail_unless (strcmp (gibber_xmpp_node_get_attribute (node, "id"),
+ "1") == 0);
+
+ g_free (data);
+ g_queue_free (received_stanzas);
+ g_object_unref (event->stanza);
+ g_free (event);
+ g_object_unref (reader);
+}
+END_TEST
+
+TCase *
+make_gibber_xmpp_reader_tcase (void)
+{
+ TCase *tc = tcase_create ("XMPP Reader");
+ tcase_add_test (tc, test_instantiation);
+ tcase_add_test (tc, test_simple_message);
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber-xmpp-stanza.c b/lib/gibber/tests/check-gibber-xmpp-stanza.c
new file mode 100644
index 0000000..ab0e62d
--- /dev/null
+++ b/lib/gibber/tests/check-gibber-xmpp-stanza.c
@@ -0,0 +1,165 @@
+/*
+ * check-gibber-xmpp-stanza.c - Test for gibber-xmpp-stanza functions
+ * Copyright (C) 2007 Collabora Ltd.
+ * @author Guillaume Desmottes <guillaume.desmottes at collabora.co.uk>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gibber/gibber-xmpp-stanza.h>
+
+#define DEBUG_FLAG DEBUG_XMPP
+#include <gibber/gibber-debug.h>
+
+#include <check.h>
+#include "check-gibber.h"
+
+START_TEST (test_build_with_html_message)
+{
+ GibberXmppStanza *stanza;
+ const gchar *body = "Telepathy rocks!",
+ *xhtml_ns = "http://www.w3.org/1999/xhtml";
+ GibberXmppNode *node;
+ const gchar *value;
+
+ g_type_init ();
+#ifdef ENABLE_DEBUG
+ gibber_debug_set_flags_from_env ();
+#endif
+
+ stanza = gibber_xmpp_stanza_build (
+ GIBBER_STANZA_TYPE_MESSAGE, GIBBER_STANZA_SUB_TYPE_NONE,
+ "alice at collabora.co.uk", "bob at collabora.co.uk",
+ GIBBER_NODE, "html",
+ GIBBER_NODE_XMLNS, xhtml_ns,
+ GIBBER_NODE, "body",
+ GIBBER_NODE_ATTRIBUTE, "textcolor", "red",
+ GIBBER_NODE_TEXT, body,
+ GIBBER_NODE_END,
+ GIBBER_NODE_END,
+ GIBBER_STANZA_END);
+
+ DEBUG_STANZA (stanza, "check");
+
+ fail_if (stanza == NULL);
+ /* <message> */
+ node = stanza->node;
+ fail_if (node == NULL);
+ fail_unless (strcmp (node->name, "message") == 0);
+ value = gibber_xmpp_node_get_attribute (node, "type");
+ fail_unless (value == NULL);
+ value = gibber_xmpp_node_get_attribute (node, "from");
+ fail_unless (strcmp (value, "alice at collabora.co.uk") == 0);
+ value = gibber_xmpp_node_get_attribute (node, "to");
+ fail_unless (strcmp (value, "bob at collabora.co.uk") == 0);
+
+ /* <html> */
+ node = gibber_xmpp_node_get_child_ns (node, "html", xhtml_ns);
+ fail_if (node == NULL);
+
+ /* <body> */
+ node = gibber_xmpp_node_get_child (node, "body");
+ fail_if (node == NULL);
+ value = gibber_xmpp_node_get_attribute (node, "textcolor");
+ fail_unless (strcmp (value, "red") == 0);
+ fail_unless (strcmp (node->content, body) == 0);
+
+ g_object_unref (stanza);
+} END_TEST
+
+START_TEST (test_get_type_info_with_simple_message)
+{
+ GibberXmppStanza *stanza;
+ GibberStanzaType type;
+ GibberStanzaSubType sub_type;
+
+ stanza = gibber_xmpp_stanza_build (
+ GIBBER_STANZA_TYPE_MESSAGE, GIBBER_STANZA_SUB_TYPE_NONE,
+ "alice at collabora.co.uk", "bob at collabora.co.uk",
+ GIBBER_STANZA_END);
+ fail_if (stanza == NULL);
+
+ gibber_xmpp_stanza_get_type_info (stanza, &type, &sub_type);
+ fail_if (type != GIBBER_STANZA_TYPE_MESSAGE);
+ fail_if (sub_type != GIBBER_STANZA_SUB_TYPE_NONE);
+
+ g_object_unref (stanza);
+} END_TEST
+
+START_TEST (test_get_type_info_with_iq_set)
+{
+ GibberXmppStanza *stanza;
+ GibberStanzaType type;
+ GibberStanzaSubType sub_type;
+
+ stanza = gibber_xmpp_stanza_build (
+ GIBBER_STANZA_TYPE_IQ, GIBBER_STANZA_SUB_TYPE_SET,
+ "alice at collabora.co.uk", "bob at collabora.co.uk",
+ GIBBER_STANZA_END);
+ fail_if (stanza == NULL);
+
+ gibber_xmpp_stanza_get_type_info (stanza, &type, &sub_type);
+ fail_if (type != GIBBER_STANZA_TYPE_IQ);
+ fail_if (sub_type != GIBBER_STANZA_SUB_TYPE_SET);
+
+ g_object_unref (stanza);
+} END_TEST
+
+START_TEST (test_get_type_info_with_unknown_type)
+{
+ GibberXmppStanza *stanza;
+ GibberStanzaType type;
+
+ stanza = gibber_xmpp_stanza_new ("goat");
+ fail_if (stanza == NULL);
+
+ gibber_xmpp_stanza_get_type_info (stanza, &type, NULL);
+ fail_if (type != GIBBER_STANZA_TYPE_UNKNOWN);
+
+ g_object_unref (stanza);
+} END_TEST
+
+START_TEST (test_get_type_info_with_unknown_sub_type)
+{
+ GibberXmppStanza *stanza;
+ GibberStanzaSubType sub_type;
+
+ stanza = gibber_xmpp_stanza_new ("iq");
+ fail_if (stanza == NULL);
+ gibber_xmpp_node_set_attribute (stanza->node, "type", "goat");
+
+ gibber_xmpp_stanza_get_type_info (stanza, NULL, &sub_type);
+ fail_if (sub_type != GIBBER_STANZA_SUB_TYPE_UNKNOWN);
+
+ g_object_unref (stanza);
+} END_TEST
+
+
+TCase *
+make_gibber_xmpp_stanza_tcase (void)
+{
+ TCase *tc = tcase_create ("XMPP Stanza");
+ tcase_add_test (tc, test_build_with_html_message);
+ tcase_add_test (tc, test_get_type_info_with_simple_message);
+ tcase_add_test (tc, test_get_type_info_with_iq_set);
+ tcase_add_test (tc, test_get_type_info_with_unknown_type);
+ tcase_add_test (tc, test_get_type_info_with_unknown_sub_type);
+ return tc;
+}
diff --git a/lib/gibber/tests/check-gibber.h b/lib/gibber/tests/check-gibber.h
new file mode 100644
index 0000000..edd747f
--- /dev/null
+++ b/lib/gibber/tests/check-gibber.h
@@ -0,0 +1,20 @@
+#ifndef __CHECK_GIBBER_H__
+#define __CHECK_GIBBER_H__
+
+#include <check.h>
+
+TCase *make_gibber_xmpp_node_tcase (void);
+TCase *make_gibber_xmpp_reader_tcase (void);
+TCase *make_gibber_xmpp_connection_tcase (void);
+TCase *make_gibber_sasl_auth_tcase (void);
+TCase *make_gibber_resolver_tcase (void);
+TCase *make_gibber_r_multicast_packet_tcase (void);
+TCase *make_gibber_r_multicast_causal_transport_tcase (void);
+TCase *make_gibber_r_multicast_sender_tcase (void);
+TCase *make_gibber_xmpp_stanza_tcase (void);
+TCase *make_gibber_iq_helper_tcase (void);
+TCase *make_gibber_listener_tcase (void);
+TCase *make_gibber_xmpp_connection_listener_tcase (void);
+TCase *make_gibber_xmpp_error_tcase (void);
+
+#endif /* #ifndef __CHECK_GIBBER_H__ */
diff --git a/lib/gibber/tests/check-helpers.c b/lib/gibber/tests/check-helpers.c
new file mode 100644
index 0000000..86ef115
--- /dev/null
+++ b/lib/gibber/tests/check-helpers.c
@@ -0,0 +1,63 @@
+/*
+ * check-helpers.c - Source for some check helpers
+ * Copyright (C) 2007 Collabora Ltd.
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "check-helpers.h"
+
+static gboolean expecting_critical = FALSE;
+static gboolean received_critical = FALSE;
+
+static void
+check_helper_log_critical_func (const gchar *log_damain,
+ GLogLevelFlags log_level,
+ const gchar *message,
+ gpointer user_data)
+{
+
+ if (!expecting_critical)
+ {
+ fail ("Unexpected critical message: %s\n", message);
+ }
+
+ g_assert (log_level & G_LOG_LEVEL_CRITICAL);
+
+ received_critical = TRUE;
+}
+
+gboolean
+got_critical (void)
+{
+ return received_critical;
+}
+
+void
+expect_critical (gboolean expected)
+{
+ expecting_critical = expected;
+ received_critical = FALSE;
+}
+
+void
+check_helpers_init (void)
+{
+ g_log_set_handler (NULL, G_LOG_LEVEL_CRITICAL,
+ check_helper_log_critical_func, NULL);
+}
diff --git a/lib/gibber/tests/check-helpers.h b/lib/gibber/tests/check-helpers.h
new file mode 100644
index 0000000..b71b3b6
--- /dev/null
+++ b/lib/gibber/tests/check-helpers.h
@@ -0,0 +1,43 @@
+/*
+ * check-helpers.c - Source for some check helpers
+ * Copyright (C) 2007 Collabora Ltd.
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+#ifndef __CHECK_HELPERS_H__
+#define __CHECK_HELPERS_H__
+
+#include <glib.h>
+#include <check.h>
+
+void
+check_helpers_init (void);
+
+void
+expect_critical (gboolean expected);
+
+gboolean
+got_critical (void);
+
+#define fail_unless_critical(expr, ...) \
+G_STMT_START { \
+ expect_critical (TRUE); \
+ expr; \
+ _fail_unless (got_critical (), __FILE__, __LINE__, \
+ "Expected g_critical, got none", ## __VA_ARGS__, NULL); \
+ expect_critical (FALSE); \
+} G_STMT_END;
+
+#endif /* #ifndef __CHECK_HELPERS_H__ */
diff --git a/lib/gibber/tests/check-main.c b/lib/gibber/tests/check-main.c
new file mode 100644
index 0000000..cf01cfe
--- /dev/null
+++ b/lib/gibber/tests/check-main.c
@@ -0,0 +1,54 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib-object.h>
+
+#include <check.h>
+
+#include "check-gibber.h"
+#include "check-helpers.h"
+
+#include "config.h"
+
+static Suite *
+make_gibber_suite (void)
+{
+ Suite *s = suite_create ("Gibber");
+
+ suite_add_tcase (s, make_gibber_xmpp_node_tcase ());
+ suite_add_tcase (s, make_gibber_xmpp_reader_tcase ());
+ suite_add_tcase (s, make_gibber_xmpp_connection_tcase ());
+#ifdef HAVE_LIBSASL2
+ suite_add_tcase (s, make_gibber_sasl_auth_tcase ());
+#endif
+ suite_add_tcase (s, make_gibber_resolver_tcase ());
+ suite_add_tcase (s, make_gibber_r_multicast_packet_tcase ());
+ suite_add_tcase (s, make_gibber_r_multicast_sender_tcase ());
+ suite_add_tcase (s, make_gibber_r_multicast_causal_transport_tcase ());
+ suite_add_tcase (s, make_gibber_xmpp_stanza_tcase ());
+ suite_add_tcase (s, make_gibber_iq_helper_tcase ());
+ suite_add_tcase (s, make_gibber_listener_tcase ());
+ suite_add_tcase (s, make_gibber_xmpp_connection_listener_tcase ());
+ suite_add_tcase (s, make_gibber_xmpp_error_tcase ());
+
+ return s;
+}
+
+int
+main (void)
+{
+ int number_failed = 0;
+ Suite *s;
+ SRunner *sr;
+
+ check_helpers_init ();
+ g_type_init ();
+
+ s = make_gibber_suite ();
+ sr = srunner_create (s);
+ srunner_run_all (sr, CK_NORMAL);
+ number_failed += srunner_ntests_failed (sr);
+ srunner_free (sr);
+
+ return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff --git a/lib/gibber/tests/inputs/Makefile.am b/lib/gibber/tests/inputs/Makefile.am
new file mode 100644
index 0000000..0b8b19f
--- /dev/null
+++ b/lib/gibber/tests/inputs/Makefile.am
@@ -0,0 +1,5 @@
+EXTRA_DIST = \
+ groupchat-invite.input \
+ simple-message-attrnamespace.input \
+ simple-message.input \
+ strange-streamopening.input
diff --git a/lib/gibber/tests/inputs/groupchat-invite.input b/lib/gibber/tests/inputs/groupchat-invite.input
new file mode 100644
index 0000000..3c7954f
--- /dev/null
+++ b/lib/gibber/tests/inputs/groupchat-invite.input
@@ -0,0 +1,32 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<stream:stream xmlns='jabber:client'
+ xmlns:stream='http://etherx.jabber.org/streams'>
+
+<message
+ from='crone1 at shakespeare.lit/desktop'
+ to='darkcave at macbeth.shakespeare.lit' id="0">
+ <x xmlns='http://jabber.org/protocol/muc#user'>
+ <invite to='hecate at shakespeare.lit'>
+ <reason>
+ Hey Hecate, this is the place for all good witches!
+ </reason>
+ </invite>
+ </x>
+</message>
+
+<message
+ from='darkcave at macbeth.shakespeare.lit'
+ to='hecate at shakespeare.lit' id="1">
+ <body>You have been invited to darkcave at macbeth by crone1 at shakespeare.lit.</body>
+ <x xmlns='http://jabber.org/protocol/muc#user'>
+ <invite from='crone1 at shakespeare.lit'>
+ <reason>
+ Hey Hecate, this is the place for all good witches!
+ </reason>
+ </invite>
+ <password>cauldronburn</password>
+ </x>
+</message>
+
+
+</stream:stream>
diff --git a/lib/gibber/tests/inputs/simple-message-attrnamespace.input b/lib/gibber/tests/inputs/simple-message-attrnamespace.input
new file mode 100644
index 0000000..b85d92f
--- /dev/null
+++ b/lib/gibber/tests/inputs/simple-message-attrnamespace.input
@@ -0,0 +1,17 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<stream:stream xmlns='jabber:client'
+ xmlns:stream='http://etherx.jabber.org/streams'>
+
+ <message to='juliet at example.com' from='romeo at example.net' xml:lang='en'
+ id="0">
+ <body>Art thou not Romeo, and a Montague?</body>
+ </message>
+
+ <message from='romeo at example.net'
+ to='juliet at example.com'
+ stream:blaat='blaat'
+ xml:lang='en' id="1">
+ <body>Neither, fair saint, if either thee dislike.</body>
+ </message>
+
+</stream:stream>
diff --git a/lib/gibber/tests/inputs/simple-message.input b/lib/gibber/tests/inputs/simple-message.input
new file mode 100644
index 0000000..a3989ae
--- /dev/null
+++ b/lib/gibber/tests/inputs/simple-message.input
@@ -0,0 +1,16 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<stream:stream xmlns='jabber:client'
+ xmlns:stream='http://etherx.jabber.org/streams'>
+
+ <message to='juliet at example.com' from='romeo at example.net' xml:lang='en'
+ id="0">
+ <body>Art thou not Romeo, and a Montague?</body>
+ </message>
+
+ <message from='romeo at example.net'
+ to='juliet at example.com'
+ xml:lang='en' id="1">
+ <body>Neither, fair saint, if either thee dislike.</body>
+ </message>
+
+</stream:stream>
diff --git a/lib/gibber/tests/inputs/strange-streamopening.input b/lib/gibber/tests/inputs/strange-streamopening.input
new file mode 100644
index 0000000..4685541
--- /dev/null
+++ b/lib/gibber/tests/inputs/strange-streamopening.input
@@ -0,0 +1,9 @@
+<?xml version='1.0' encoding='utf-8'?>
+<stream:stream xmlns='jabber:client'
+ xmlns:stream='http://etherx.jabber.org/streams'
+ from='rome"&@example.net'
+ to='ex"&ample.net'>
+
+ <aap bla="&" id="0"/>
+
+</stream:stream>
diff --git a/lib/gibber/tests/inputs/tls-stream-start.input b/lib/gibber/tests/inputs/tls-stream-start.input
new file mode 100644
index 0000000..d30bcf8
--- /dev/null
+++ b/lib/gibber/tests/inputs/tls-stream-start.input
@@ -0,0 +1,18 @@
+<stream:stream
+ xmlns='jabber:client'
+ xmlns:stream='http://etherx.jabber.org/streams'
+ to='example.com'
+ version='1.0'>
+
+ <stream:features id="0">
+ <starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'>
+ <required/>
+ </starttls>
+ <mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>
+ <mechanism>DIGEST-MD5</mechanism>
+ <mechanism>PLAIN</mechanism>
+ </mechanisms>
+ </stream:features>
+
+ <starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls' id="1"/>
+</stream:stream>
diff --git a/lib/gibber/tests/run-xmpp-connection-test.sh b/lib/gibber/tests/run-xmpp-connection-test.sh
new file mode 100755
index 0000000..e2337ab
--- /dev/null
+++ b/lib/gibber/tests/run-xmpp-connection-test.sh
@@ -0,0 +1,29 @@
+#!/bin/sh
+
+mkdir -p outputs
+
+RET=0
+
+
+srcdir=${srdir:=$(dirname $0)}
+
+for x in ${srcdir}/inputs/*.input ; do
+ FILE=$(basename ${x%.input})
+ XMLOUT="outputs/${FILE}.output"
+ PARSEOUT="outputs/${FILE}.parse"
+ ./test-xmpp-connection $x ${PARSEOUT} ${XMLOUT}
+ if [ $? -ne 0 ] ; then
+ echo "FAILED: $x - Test program had non-zero exit status" >&2
+ RET=1
+ continue
+ fi
+ xmldiff $x $XMLOUT
+ if [ $? -ne 0 ] ; then
+ echo "FAILED: $x - XML output doesn't match the input" >&2
+ RET=1
+ continue
+ fi
+ echo "SUCCESS: $x" >&2
+done
+
+exit ${RET}
diff --git a/lib/gibber/tests/test-r-multicast-transport-io.c b/lib/gibber/tests/test-r-multicast-transport-io.c
new file mode 100644
index 0000000..62a4e96
--- /dev/null
+++ b/lib/gibber/tests/test-r-multicast-transport-io.c
@@ -0,0 +1,226 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glib.h>
+
+#include <gibber/gibber-r-multicast-transport.h>
+#include <gibber/gibber-debug.h>
+#include "test-transport.h"
+
+GMainLoop *loop;
+
+TestTransport *t;
+GibberRMulticastTransport *rm;
+GibberRMulticastCausalTransport *rmc;
+gulong rmc_connected_handler = 0;
+
+static void
+received_data (GibberTransport *transport, GibberBuffer *buffer,
+ gpointer user_data)
+{
+ GibberRMulticastBuffer *rmbuffer = (GibberRMulticastBuffer *) buffer;
+ gchar *b64;
+
+ b64 = g_base64_encode ((guchar *) buffer->data, buffer->length);
+ printf ("OUTPUT:%s:%s\n", rmbuffer->sender, b64);
+ fflush (stdout);
+ g_free (b64);
+}
+
+static gboolean
+send_hook (GibberTransport *transport, const guint8 *data, gsize length,
+ GError **error, gpointer user_data)
+{
+ gchar *b64;
+
+ b64 = g_base64_encode ((guchar *) data, length);
+ printf ("SEND:%s\n", b64);
+ fflush (stdout);
+ g_free (b64);
+
+ return TRUE;
+}
+
+static void
+fail_node (gchar *name)
+{
+ GibberRMulticastSender *sender;
+
+ name = g_strstrip (name);
+
+ sender = gibber_r_multicast_causal_transport_get_sender_by_name (rmc, name);
+ g_assert (sender != NULL);
+
+ _gibber_r_multicast_TEST_sender_fail (sender);
+}
+
+static gboolean
+got_input (GIOChannel *source, GIOCondition condition, gpointer user_data)
+{
+ GIOStatus s;
+ gchar *buffer;
+ gsize len;
+ gchar *p;
+ gboolean packet = FALSE;
+ guchar *b64;
+ gsize size;
+
+ s = g_io_channel_read_line (source, &buffer, &len, NULL, NULL);
+ g_assert (s == G_IO_STATUS_NORMAL);
+
+ if (g_str_has_prefix (buffer, "INPUT:"))
+ {
+ packet = FALSE;
+ p = buffer + strlen ("INPUT:");
+ }
+ else if (g_str_has_prefix (buffer, "RECV:"))
+ {
+ packet = TRUE;
+ p = buffer + strlen ("RECV:");
+ }
+ else if (strcmp (buffer, "DISCONNECT\n") == 0)
+ {
+ gibber_transport_disconnect (GIBBER_TRANSPORT(rm));
+ goto out;
+ }
+ else if (g_str_has_prefix (buffer, "FAIL:"))
+ {
+ /* this will modify our buffer */
+ fail_node (buffer + strlen ("FAIL:"));
+ goto out;
+ }
+ else
+ {
+ g_assert_not_reached ();
+ }
+
+ b64 = g_base64_decode (p, &size);
+
+ if (packet)
+ {
+ test_transport_write (t, b64, size);
+ }
+ else
+ {
+ g_assert (gibber_transport_send (GIBBER_TRANSPORT (rm),
+ b64, size, NULL));
+ }
+
+ g_free (b64);
+out:
+ g_free (buffer);
+
+ return TRUE;
+}
+
+static gboolean
+got_error (GIOChannel *source, GIOCondition condition, gpointer user_data)
+{
+ g_main_loop_quit (loop);
+ fprintf (stderr, "error");
+ fflush (stderr);
+ return TRUE;
+}
+
+static void
+new_senders_cb (GibberRMulticastTransport *transport,
+ GArray *names, gpointer user_data)
+{
+ guint i;
+ GString *str = g_string_new ("NEWNODES:");
+
+ for (i = 0; i < names->len; i++)
+ {
+ g_string_append_printf (str, "%s ", g_array_index (names, gchar *, i));
+ }
+ printf ("%s\n", str->str);
+ g_string_free (str, TRUE);
+ fflush (stdout);
+}
+
+static void
+lost_senders_cb (GibberRMulticastTransport *transport,
+ GArray *names, gpointer user_data)
+{
+ guint i;
+ GString *str = g_string_new ("LOSTNODES:");
+
+ for (i = 0; i < names->len; i++)
+ {
+ g_string_append_printf (str, "%s ", g_array_index (names, gchar *, i));
+ }
+ printf ("%s\n", str->str);
+ g_string_free (str, TRUE);
+ fflush (stdout);
+}
+
+static void
+rm_connected (GibberRMulticastTransport *transport, gpointer user_data)
+{
+ printf ("CONNECTED:\n");
+ fflush (stdout);
+}
+
+static void
+rm_disconnected (GibberRMulticastTransport *transport, gpointer user_data)
+{
+ printf ("DISCONNECTED:\n");
+ fflush (stdout);
+ g_main_loop_quit (loop);
+}
+
+static void
+rmc_connected (GibberRMulticastTransport *transport, gpointer user_data)
+{
+ g_assert (gibber_r_multicast_transport_connect (rm, NULL));
+ g_signal_handler_disconnect (transport, rmc_connected_handler);
+}
+
+int
+main (int argc, char **argv)
+{
+ GIOChannel *io;
+
+ g_assert (argc == 2);
+
+ g_type_init ();
+
+ printf ("Starting process %d for %s\n", getpid (), argv[1]);
+
+ loop = g_main_loop_new (NULL, FALSE);
+
+ t = test_transport_new (send_hook, argv[1]);
+ GIBBER_TRANSPORT (t)->max_packet_size = 1500;
+ test_transport_set_echoing (t, TRUE);
+
+ rmc = gibber_r_multicast_causal_transport_new (GIBBER_TRANSPORT (t),
+ argv[1]);
+ g_object_unref (t);
+
+ rm = gibber_r_multicast_transport_new (rmc);
+ gibber_transport_set_handler (GIBBER_TRANSPORT (rm), received_data, argv[1]);
+ g_object_unref (rmc);
+
+ g_signal_connect (rm, "new-senders", G_CALLBACK (new_senders_cb), NULL);
+
+ g_signal_connect (rm, "lost-senders", G_CALLBACK (lost_senders_cb), NULL);
+
+ rmc_connected_handler = g_signal_connect (rmc, "connected",
+ G_CALLBACK (rmc_connected), NULL);
+
+ g_signal_connect (rm, "connected", G_CALLBACK (rm_connected), NULL);
+
+ g_signal_connect (rm, "disconnected", G_CALLBACK (rm_disconnected), NULL);
+
+ /* test transport starts out connected */
+ g_assert (gibber_r_multicast_causal_transport_connect (rmc, FALSE, NULL));
+
+ io = g_io_channel_unix_new (STDIN_FILENO);
+ g_io_add_watch (io, G_IO_IN, got_input, NULL);
+ g_io_add_watch (io, G_IO_HUP|G_IO_ERR, got_error, NULL);
+
+ g_main_loop_run (loop);
+
+ return 0;
+}
diff --git a/lib/gibber/tests/test-resolver.c b/lib/gibber/tests/test-resolver.c
new file mode 100644
index 0000000..bb6ab8d
--- /dev/null
+++ b/lib/gibber/tests/test-resolver.c
@@ -0,0 +1,113 @@
+/*
+ * test-resolver.c - Source for TestResolver
+ * Copyright (C) 2008 Collabora Ltd.
+ * @author Sjoerd Simons <sjoerd.simons at collabora.co.uk>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "test-resolver.h"
+
+G_DEFINE_TYPE(TestResolver, test_resolver, GIBBER_TYPE_RESOLVER)
+
+/* private structure */
+typedef struct _TestResolverPrivate TestResolverPrivate;
+
+struct _TestResolverPrivate
+{
+ gboolean dispose_has_run;
+};
+
+#define TEST_RESOLVER_GET_PRIVATE(o) \
+ (G_TYPE_INSTANCE_GET_PRIVATE ((o), TEST_TYPE_RESOLVER, TestResolverPrivate))
+
+static void
+test_resolver_init (TestResolver *obj)
+{
+}
+
+static void test_resolver_dispose (GObject *object);
+static void test_resolver_finalize (GObject *object);
+
+static gboolean test_resolv_srv (GibberResolver *resolver, guint id,
+ const gchar *service_name, const char *service,
+ GibberResolverServiceType type);
+
+static void
+test_resolver_class_init (TestResolverClass *test_resolver_class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (test_resolver_class);
+ GibberResolverClass *resolver_class = GIBBER_RESOLVER_CLASS
+ (test_resolver_class);
+
+ g_type_class_add_private (test_resolver_class, sizeof (TestResolverPrivate));
+
+ object_class->dispose = test_resolver_dispose;
+ object_class->finalize = test_resolver_finalize;
+
+ resolver_class->resolv_srv = test_resolv_srv;
+}
+
+void
+test_resolver_dispose (GObject *object)
+{
+ TestResolver *self = TEST_RESOLVER (object);
+ TestResolverPrivate *priv = TEST_RESOLVER_GET_PRIVATE (self);
+
+ if (priv->dispose_has_run)
+ return;
+
+ priv->dispose_has_run = TRUE;
+
+ /* release any references held by the object here */
+
+ if (G_OBJECT_CLASS (test_resolver_parent_class)->dispose)
+ G_OBJECT_CLASS (test_resolver_parent_class)->dispose (object);
+}
+
+void
+test_resolver_finalize (GObject *object)
+{
+ G_OBJECT_CLASS (test_resolver_parent_class)->finalize (object);
+}
+
+
+static gboolean test_resolv_srv (GibberResolver *resolver, guint id,
+ const gchar *service_name, const char *service,
+ GibberResolverServiceType type)
+{
+ GList *entries = NULL;
+ int i;
+
+ for (i = 0 ; i < 20 ; i++)
+ {
+ gchar *str;
+
+ str = g_strdup_printf ("test%2d.example.com", i);
+
+ entries = g_list_prepend (entries,
+ gibber_resolver_srv_record_new (str, 1234,
+ 10 - (i / 5) , 4 - i % 5));
+
+ g_free (str);
+ }
+
+ gibber_resolver_srv_result (resolver, id, entries, NULL);
+ return FALSE;
+}
diff --git a/lib/gibber/tests/test-resolver.h b/lib/gibber/tests/test-resolver.h
new file mode 100644
index 0000000..1d39e4e
--- /dev/null
+++ b/lib/gibber/tests/test-resolver.h
@@ -0,0 +1,59 @@
+/*
+ * test-resolver.h - Header for TestResolver
+ * Copyright (C) 2008 Collabora Ltd.
+ * @author Sjoerd Simons <sjoerd.simons at collabora.co.uk>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef __TEST_RESOLVER_H__
+#define __TEST_RESOLVER_H__
+
+#include <glib-object.h>
+#include <gibber/gibber-resolver.h>
+
+G_BEGIN_DECLS
+
+typedef struct _TestResolver TestResolver;
+typedef struct _TestResolverClass TestResolverClass;
+
+struct _TestResolverClass {
+ GibberResolverClass parent_class;
+};
+
+struct _TestResolver {
+ GibberResolver parent;
+};
+
+GType test_resolver_get_type (void);
+
+/* TYPE MACROS */
+#define TEST_TYPE_RESOLVER \
+ (test_resolver_get_type ())
+#define TEST_RESOLVER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), TEST_TYPE_RESOLVER, TestResolver))
+#define TEST_RESOLVER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_RESOLVER, TestResolverClass))
+#define TEST_IS_RESOLVER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), TEST_TYPE_RESOLVER))
+#define TEST_IS_RESOLVER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_RESOLVER))
+#define TEST_RESOLVER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_RESOLVER, TestResolverClass))
+
+
+G_END_DECLS
+
+#endif /* #ifndef __TEST_RESOLVER_H__*/
diff --git a/lib/gibber/tests/test-sasl-auth-server-signals-marshal.list b/lib/gibber/tests/test-sasl-auth-server-signals-marshal.list
new file mode 100644
index 0000000..e69de29
diff --git a/lib/gibber/tests/test-sasl-auth-server.c b/lib/gibber/tests/test-sasl-auth-server.c
new file mode 100644
index 0000000..7132122
--- /dev/null
+++ b/lib/gibber/tests/test-sasl-auth-server.c
@@ -0,0 +1,460 @@
+/*
+ * test-sasl-auth-server.c - Source for TestSaslAuthServer
+ * Copyright (C) 2006 Collabora Ltd.
+ * @author Sjoerd Simons <sjoerd at luon.net>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "test-sasl-auth-server.h"
+
+#include <gibber/gibber-xmpp-stanza.h>
+#include <gibber/gibber-xmpp-connection.h>
+#include <gibber/gibber-transport.h>
+
+#include <gibber/gibber-namespaces.h>
+
+#include <sasl/sasl.h>
+
+#define CHECK_SASL_RETURN(x) \
+G_STMT_START { \
+ if (x < SASL_OK) { \
+ fprintf (stderr, "sasl error (%d): %s\n", \
+ ret, sasl_errdetail (priv->sasl_conn)); \
+ g_assert_not_reached (); \
+ } \
+} G_STMT_END
+
+G_DEFINE_TYPE(TestSaslAuthServer, test_sasl_auth_server, G_TYPE_OBJECT)
+
+#if 0
+/* signal enum */
+enum
+{
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = {0};
+#endif
+
+typedef enum {
+ AUTH_STATE_STARTED,
+ AUTH_STATE_CHALLENGE,
+ AUTH_STATE_FINAL_CHALLENGE,
+ AUTH_STATE_AUTHENTICATED,
+} AuthState;
+
+/* private structure */
+typedef struct _TestSaslAuthServerPrivate TestSaslAuthServerPrivate;
+
+struct _TestSaslAuthServerPrivate
+{
+ gboolean dispose_has_run;
+ GibberXmppConnection *conn;
+ sasl_conn_t *sasl_conn;
+ gchar *username;
+ gchar *password;
+ gchar *mech;
+ AuthState state;
+ ServerProblem problem;
+};
+
+#define TEST_SASL_AUTH_SERVER_GET_PRIVATE(o) \
+ (G_TYPE_INSTANCE_GET_PRIVATE ((o), TEST_TYPE_SASL_AUTH_SERVER, \
+ TestSaslAuthServerPrivate))
+
+static void
+test_sasl_auth_server_init (TestSaslAuthServer *obj)
+{
+ TestSaslAuthServerPrivate *priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (obj);
+ priv->username = NULL;
+ priv->password = NULL;
+ priv->mech = NULL;
+ priv->state = AUTH_STATE_STARTED;
+
+ /* allocate any data required by the object here */
+}
+
+static void test_sasl_auth_server_dispose (GObject *object);
+static void test_sasl_auth_server_finalize (GObject *object);
+
+static void
+test_sasl_auth_server_class_init (
+ TestSaslAuthServerClass *test_sasl_auth_server_class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (test_sasl_auth_server_class);
+
+ g_type_class_add_private (test_sasl_auth_server_class,
+ sizeof (TestSaslAuthServerPrivate));
+
+ object_class->dispose = test_sasl_auth_server_dispose;
+ object_class->finalize = test_sasl_auth_server_finalize;
+
+}
+
+void
+test_sasl_auth_server_dispose (GObject *object)
+{
+ TestSaslAuthServer *self = TEST_SASL_AUTH_SERVER (object);
+ TestSaslAuthServerPrivate *priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (self);
+
+ if (priv->dispose_has_run)
+ return;
+
+ priv->dispose_has_run = TRUE;
+
+ /* release any references held by the object here */
+ g_object_unref (priv->conn);
+
+ if (G_OBJECT_CLASS (test_sasl_auth_server_parent_class)->dispose)
+ G_OBJECT_CLASS (test_sasl_auth_server_parent_class)->dispose (object);
+}
+
+void
+test_sasl_auth_server_finalize (GObject *object)
+{
+ TestSaslAuthServer *self = TEST_SASL_AUTH_SERVER (object);
+ TestSaslAuthServerPrivate *priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (self);
+
+ /* free any data held directly by the object here */
+ g_free (priv->username);
+ g_free (priv->password);
+ g_free (priv->mech);
+
+ G_OBJECT_CLASS (test_sasl_auth_server_parent_class)->finalize (object);
+}
+
+static void
+parse_error (GibberXmppConnection *connection, gpointer user_data)
+{
+ fprintf (stderr, "PARSING FAILED IN SASL SERVER\n");
+ g_assert_not_reached ();
+}
+
+static void
+stream_opened (GibberXmppConnection *connection, const gchar *to,
+ const gchar *from, const gchar *version, gpointer user_data)
+{
+ TestSaslAuthServer *self = TEST_SASL_AUTH_SERVER(user_data);
+ TestSaslAuthServerPrivate * priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (self);
+ GibberXmppStanza *stanza;
+ GibberXmppNode *mechnode = NULL;
+
+ gibber_xmpp_connection_open (connection, NULL, "testserver", "1.0");
+ /* Send stream features */
+ stanza = gibber_xmpp_stanza_new ("features");
+ gibber_xmpp_node_set_ns (stanza->node, GIBBER_XMPP_NS_STREAM);
+
+ if (priv->problem != SERVER_PROBLEM_NO_SASL)
+ {
+ mechnode = gibber_xmpp_node_add_child_ns (stanza->node,
+ "mechanisms", GIBBER_XMPP_NS_SASL_AUTH);
+ if (priv->problem == SERVER_PROBLEM_NO_MECHANISMS)
+ {
+ /* lalala */
+ }
+ else if (priv->mech != NULL)
+ {
+ gibber_xmpp_node_add_child_with_content (mechnode, "mechanism",
+ priv->mech);
+ }
+ else
+ {
+ const gchar *mechs;
+ gchar **mechlist;
+ gchar **tmp;
+ int ret;
+ ret = sasl_listmech (priv->sasl_conn, NULL, "","\n","", &mechs,
+ NULL,NULL);
+ CHECK_SASL_RETURN (ret);
+ mechlist = g_strsplit (mechs, "\n", -1);
+ for (tmp = mechlist; *tmp != NULL; tmp++)
+ {
+ gibber_xmpp_node_add_child_with_content (mechnode,
+ "mechanism", *tmp);
+ }
+ g_strfreev (mechlist);
+ }
+ }
+
+ g_assert (gibber_xmpp_connection_send (connection, stanza, NULL));
+ g_object_unref (stanza);
+}
+
+static void
+stream_closed (GibberXmppConnection *connection, gpointer user_data)
+{
+ gibber_xmpp_connection_close (connection);
+}
+
+static void
+auth_succeeded (TestSaslAuthServer *self)
+{
+ TestSaslAuthServerPrivate * priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE(self);
+ GibberXmppStanza *s;
+
+ g_assert (priv->state < AUTH_STATE_AUTHENTICATED);
+ priv->state = AUTH_STATE_AUTHENTICATED;
+
+ s = gibber_xmpp_stanza_new ("success");
+ gibber_xmpp_node_set_ns (s->node, GIBBER_XMPP_NS_SASL_AUTH);
+
+ /* As a result of how the test works, sending out the success will cause the
+ * reopening of the stream, so we need to restart the connection first! */
+ gibber_xmpp_connection_restart (priv->conn);
+
+ g_assert (gibber_xmpp_connection_send (priv->conn, s, NULL));
+
+ g_object_unref (s);
+}
+
+static void
+handle_auth (TestSaslAuthServer *self, GibberXmppStanza *stanza)
+{
+ TestSaslAuthServerPrivate *priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (self);
+ const gchar *mech = gibber_xmpp_node_get_attribute (stanza->node,
+ "mechanism");
+ guchar *response = NULL;
+ const gchar *challenge;
+ unsigned challenge_len;
+ gsize response_len = 0;
+ int ret;
+
+ if (stanza->node->content != NULL)
+ {
+ response = g_base64_decode (stanza->node->content, &response_len);
+ }
+
+ g_assert (priv->state == AUTH_STATE_STARTED);
+ priv->state = AUTH_STATE_CHALLENGE;
+
+
+ ret = sasl_server_start (priv->sasl_conn, mech, (gchar *) response,
+ (unsigned) response_len, &challenge, &challenge_len);
+
+ CHECK_SASL_RETURN (ret);
+ if (challenge_len > 0)
+ {
+ GibberXmppStanza *c;
+ gchar *challenge64;
+
+ if (ret == SASL_OK)
+ {
+ priv->state = AUTH_STATE_FINAL_CHALLENGE;
+ }
+
+ challenge64 = g_base64_encode ((guchar *) challenge, challenge_len);
+
+ c = gibber_xmpp_stanza_new ("challenge");
+ gibber_xmpp_node_set_ns (c->node, GIBBER_XMPP_NS_SASL_AUTH);
+ gibber_xmpp_node_set_content (c->node, challenge64);
+ g_assert (gibber_xmpp_connection_send (priv->conn, c, NULL));
+ g_object_unref (c);
+
+ g_free (challenge64);
+ }
+ else if (ret == SASL_OK)
+ {
+ auth_succeeded (self);
+ }
+ else
+ {
+ g_assert_not_reached ();
+ }
+
+ g_free (response);
+}
+
+static void
+handle_response (TestSaslAuthServer *self, GibberXmppStanza *stanza)
+{
+ TestSaslAuthServerPrivate * priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (self);
+ guchar *response = NULL;
+ const gchar *challenge;
+ unsigned challenge_len;
+ gsize response_len = 0;
+ int ret;
+
+
+ if (priv->state == AUTH_STATE_FINAL_CHALLENGE)
+ {
+ g_assert (stanza->node->content == NULL);
+ auth_succeeded (self);
+ return;
+ }
+
+ g_assert (priv->state == AUTH_STATE_CHALLENGE);
+
+ if (stanza->node->content != NULL)
+ {
+ response = g_base64_decode (stanza->node->content, &response_len);
+ }
+
+ ret = sasl_server_step (priv->sasl_conn, (gchar *) response,
+ (unsigned) response_len, &challenge, &challenge_len);
+
+ CHECK_SASL_RETURN (ret);
+
+ if (challenge_len > 0)
+ {
+ GibberXmppStanza *c;
+ gchar *challenge64;
+
+ if (ret == SASL_OK)
+ {
+ priv->state = AUTH_STATE_FINAL_CHALLENGE;
+ }
+
+ challenge64 = g_base64_encode ((guchar *) challenge, challenge_len);
+
+ c = gibber_xmpp_stanza_new ("challenge");
+ gibber_xmpp_node_set_ns (c->node, GIBBER_XMPP_NS_SASL_AUTH);
+ gibber_xmpp_node_set_content (c->node, challenge64);
+ g_assert (gibber_xmpp_connection_send (priv->conn, c, NULL));
+ g_object_unref (c);
+
+ g_free (challenge64);
+ }
+ else if (ret == SASL_OK)
+ {
+ auth_succeeded (self);
+ }
+ else
+ {
+ g_assert_not_reached ();
+ }
+
+ g_free (response);
+}
+
+#define HANDLE(x) { #x, handle_##x }
+static void
+received_stanza (GibberXmppConnection *connection, GibberXmppStanza *stanza,
+ gpointer user_data)
+{
+ TestSaslAuthServer *self = TEST_SASL_AUTH_SERVER (user_data);
+ int i;
+ struct {
+ const gchar *name;
+ void (*func)(TestSaslAuthServer *self, GibberXmppStanza *stanza);
+ } handlers[] = { HANDLE(auth), HANDLE(response) };
+
+ if (strcmp (gibber_xmpp_node_get_ns (stanza->node),
+ GIBBER_XMPP_NS_SASL_AUTH))
+ {
+ g_assert_not_reached ();
+ }
+
+ for (i = 0 ; handlers[i].name != NULL; i++)
+ {
+ if (!strcmp (stanza->node->name, handlers[i].name))
+ {
+ handlers[i].func (self, stanza);
+ return;
+ }
+ }
+
+ g_assert_not_reached ();
+}
+
+static int
+test_sasl_server_auth_log (void *context, int level, const gchar *message)
+{
+ return SASL_OK;
+}
+
+static int
+test_sasl_server_auth_getopt (void *context, const char *plugin_name,
+ const gchar *option, const gchar **result, guint *len)
+{
+ int i;
+ static const struct {
+ const gchar *name;
+ const gchar *value;
+ } options[] = {
+ { "auxprop_plugin", "sasldb"},
+ { "sasldb_path", "./sasl-test.db"},
+ { NULL, NULL },
+ };
+
+ for (i = 0; options[i].name != NULL; i++)
+ {
+ if (!strcmp (option, options[i].name))
+ {
+ *result = options[i].value;
+ if (len != NULL)
+ *len = strlen (options[i].value);
+ }
+ }
+
+ return SASL_OK;
+}
+
+TestSaslAuthServer *
+test_sasl_auth_server_new (GibberTransport *transport, gchar *mech,
+ const gchar *user, const gchar *password, ServerProblem problem)
+{
+ TestSaslAuthServer *server;
+ TestSaslAuthServerPrivate *priv;
+ static gboolean sasl_initialized = FALSE;
+ int ret;
+ static sasl_callback_t callbacks[] = {
+ { SASL_CB_LOG, test_sasl_server_auth_log, NULL },
+ { SASL_CB_GETOPT, test_sasl_server_auth_getopt, NULL },
+ { SASL_CB_LIST_END, NULL, NULL },
+ };
+
+ if (!sasl_initialized)
+ {
+ sasl_server_init (NULL, NULL);
+ sasl_initialized = TRUE;
+ }
+
+ server = g_object_new (TEST_TYPE_SASL_AUTH_SERVER, NULL);
+ priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (server);
+
+ priv->state = AUTH_STATE_STARTED;
+
+ ret = sasl_server_new ("xmpp", NULL, NULL, NULL, NULL, callbacks,
+ SASL_SUCCESS_DATA, &(priv->sasl_conn));
+ CHECK_SASL_RETURN (ret);
+
+ ret = sasl_setpass (priv->sasl_conn, user, password, strlen (password),
+ NULL, 0, SASL_SET_CREATE);
+
+ CHECK_SASL_RETURN (ret);
+
+ priv->username = g_strdup (user);
+ priv->password = g_strdup (password);
+ priv->mech = g_strdup (mech);
+ priv->problem = problem;
+
+ priv->conn = gibber_xmpp_connection_new (transport);
+ g_signal_connect (priv->conn, "parse-error",
+ G_CALLBACK (parse_error), server);
+ g_signal_connect (priv->conn, "stream-opened",
+ G_CALLBACK (stream_opened), server);
+ g_signal_connect (priv->conn, "stream-closed",
+ G_CALLBACK (stream_closed), server);
+ g_signal_connect (priv->conn, "received-stanza",
+ G_CALLBACK (received_stanza), server);
+
+ return server;
+}
diff --git a/lib/gibber/tests/test-sasl-auth-server.h b/lib/gibber/tests/test-sasl-auth-server.h
new file mode 100644
index 0000000..cbfe95e
--- /dev/null
+++ b/lib/gibber/tests/test-sasl-auth-server.h
@@ -0,0 +1,73 @@
+/*
+ * test-sasl-auth-server.h - Header for TestSaslAuthServer
+ * Copyright (C) 2006 Collabora Ltd.
+ * @author Sjoerd Simons <sjoerd at luon.net>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef __TEST_SASL_AUTH_SERVER_H__
+#define __TEST_SASL_AUTH_SERVER_H__
+
+#include <glib-object.h>
+
+#include <gibber/gibber-transport.h>
+
+G_BEGIN_DECLS
+
+typedef enum {
+ SERVER_PROBLEM_NO_PROBLEM,
+ SERVER_PROBLEM_NO_SASL,
+ SERVER_PROBLEM_NO_MECHANISMS,
+} ServerProblem;
+
+typedef struct _TestSaslAuthServer TestSaslAuthServer;
+typedef struct _TestSaslAuthServerClass TestSaslAuthServerClass;
+
+struct _TestSaslAuthServerClass {
+ GObjectClass parent_class;
+};
+
+struct _TestSaslAuthServer {
+ GObject parent;
+};
+
+GType test_sasl_auth_server_get_type (void);
+
+/* TYPE MACROS */
+#define TEST_TYPE_SASL_AUTH_SERVER \
+ (test_sasl_auth_server_get_type ())
+#define TEST_SASL_AUTH_SERVER(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), TEST_TYPE_SASL_AUTH_SERVER, \
+ TestSaslAuthServer))
+#define TEST_SASL_AUTH_SERVER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_SASL_AUTH_SERVER, \
+ TestSaslAuthServerClass))
+#define TEST_IS_SASL_AUTH_SERVER(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), TEST_TYPE_SASL_AUTH_SERVER))
+#define TEST_IS_SASL_AUTH_SERVER_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_SASL_AUTH_SERVER))
+#define TEST_SASL_AUTH_SERVER_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_SASL_AUTH_SERVER, \
+ TestSaslAuthServerClass))
+
+
+TestSaslAuthServer * test_sasl_auth_server_new (GibberTransport *transport,
+ gchar *mech, const gchar *user, const gchar *password,
+ ServerProblem problem);
+
+G_END_DECLS
+
+#endif /* #ifndef __TEST_SASL_AUTH_SERVER_H__*/
diff --git a/lib/gibber/tests/test-transport.c b/lib/gibber/tests/test-transport.c
new file mode 100644
index 0000000..78bd566
--- /dev/null
+++ b/lib/gibber/tests/test-transport.c
@@ -0,0 +1,209 @@
+/*
+ * test-transport.c - Source for TestTransport
+ * Copyright (C) 2006 Collabora Ltd.
+ * @author Sjoerd Simons <sjoerd at luon.net>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "test-transport.h"
+
+static gboolean
+test_transport_send (GibberTransport *transport, const guint8 *data,
+ gsize size, GError **error);
+
+void test_transport_disconnect (GibberTransport *transport);
+
+G_DEFINE_TYPE (TestTransport, test_transport, GIBBER_TYPE_TRANSPORT)
+
+/* private structure */
+typedef struct _TestTransportPrivate TestTransportPrivate;
+
+struct _TestTransportPrivate
+{
+ gboolean dispose_has_run;
+ test_transport_send_hook send;
+ GQueue *buffers;
+ guint send_id;
+ gpointer user_data;
+
+ gboolean echoing;
+};
+
+#define TEST_TRANSPORT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
+ TEST_TYPE_TRANSPORT, TestTransportPrivate))
+
+static void
+test_transport_init (TestTransport *obj)
+{
+ TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (obj);
+
+ /* allocate any data required by the object here */
+ priv->send = NULL;
+ priv->buffers = g_queue_new ();
+ priv->send_id = 0;
+}
+
+static void test_transport_dispose (GObject *object);
+static void test_transport_finalize (GObject *object);
+
+static void
+test_transport_class_init (TestTransportClass *test_transport_class)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (test_transport_class);
+ GibberTransportClass *transport_class =
+ GIBBER_TRANSPORT_CLASS(test_transport_class);
+
+ g_type_class_add_private (test_transport_class, sizeof (TestTransportPrivate));
+
+ object_class->dispose = test_transport_dispose;
+ object_class->finalize = test_transport_finalize;
+
+ transport_class->send = test_transport_send;
+ transport_class->disconnect = test_transport_disconnect;
+}
+
+void
+test_transport_dispose (GObject *object)
+{
+ TestTransport *self = TEST_TRANSPORT (object);
+ TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (self);
+
+ if (priv->dispose_has_run)
+ return;
+
+ if (priv->send_id != 0)
+ g_source_remove (priv->send_id);
+
+ priv->dispose_has_run = TRUE;
+
+ /* release any references held by the object here */
+
+ if (G_OBJECT_CLASS (test_transport_parent_class)->dispose)
+ G_OBJECT_CLASS (test_transport_parent_class)->dispose (object);
+}
+
+static void
+free_array (gpointer data, gpointer user_data)
+{
+ g_array_free ((GArray *) data, TRUE);
+}
+
+void
+test_transport_finalize (GObject *object)
+{
+ TestTransport *self = TEST_TRANSPORT (object);
+ TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (self);
+
+ /* free any data held directly by the object here */
+ g_queue_foreach (priv->buffers, free_array, NULL);
+ g_queue_free (priv->buffers);
+ G_OBJECT_CLASS (test_transport_parent_class)->finalize (object);
+}
+
+static gboolean
+send_data (gpointer data)
+{
+ TestTransport *self = TEST_TRANSPORT (data);
+ TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (self);
+ GArray *arr;
+
+ g_assert (priv->send != NULL);
+
+ arr = (GArray *) g_queue_pop_head (priv->buffers);
+
+ priv->send (GIBBER_TRANSPORT (self),
+ (guint8 *) arr->data, arr->len, NULL, priv->user_data);
+
+ g_array_free (arr, TRUE);
+
+ if (g_queue_is_empty (priv->buffers))
+ {
+ priv->send_id = 0;
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static gboolean
+test_transport_send (GibberTransport *transport,
+ const guint8 *data, gsize size, GError **error)
+{
+ TestTransport *self = TEST_TRANSPORT (transport);
+ TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (self);
+
+ GArray *arr;
+
+ if (priv->echoing)
+ {
+ test_transport_write (self, data, size);
+ }
+
+ arr = g_array_sized_new (FALSE, TRUE, sizeof (guint8), size);
+ g_array_append_vals (arr, data, size);
+
+ g_queue_push_tail (priv->buffers, arr);
+
+ if (priv->send_id == 0)
+ {
+ priv->send_id = g_idle_add (send_data, transport);
+ }
+
+ return TRUE;
+}
+
+void
+test_transport_disconnect (GibberTransport *transport)
+{
+ gibber_transport_set_state (GIBBER_TRANSPORT(transport),
+ GIBBER_TRANSPORT_DISCONNECTED);
+}
+
+
+TestTransport *
+test_transport_new (test_transport_send_hook send_, gpointer user_data)
+{
+ TestTransport *self;
+ TestTransportPrivate *priv;
+
+ self = g_object_new (TEST_TYPE_TRANSPORT, NULL);
+ priv = TEST_TRANSPORT_GET_PRIVATE (self);
+ priv->send = send_;
+ priv->user_data = user_data;
+
+ gibber_transport_set_state (GIBBER_TRANSPORT(self),
+ GIBBER_TRANSPORT_CONNECTED);
+
+ return self;
+}
+
+void
+test_transport_set_echoing (TestTransport *transport, gboolean echo)
+{
+ TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (transport);
+ priv->echoing = echo;
+}
+
+
+void
+test_transport_write (TestTransport *transport, const guint8 *buf, gsize size)
+{
+ gibber_transport_received_data (GIBBER_TRANSPORT (transport), buf, size);
+}
diff --git a/lib/gibber/tests/test-transport.h b/lib/gibber/tests/test-transport.h
new file mode 100644
index 0000000..1e76d13
--- /dev/null
+++ b/lib/gibber/tests/test-transport.h
@@ -0,0 +1,73 @@
+/*
+ * test-transport.h - Header for TestTransport
+ * Copyright (C) 2006 Collabora Ltd.
+ * @author Sjoerd Simons <sjoerd at luon.net>
+ *
+ * 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, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef __TEST_TRANSPORT_H__
+#define __TEST_TRANSPORT_H__
+
+#include <glib-object.h>
+
+#include <gibber/gibber-transport.h>
+
+G_BEGIN_DECLS
+
+typedef struct _TestTransport TestTransport;
+typedef struct _TestTransportClass TestTransportClass;
+
+struct _TestTransportClass {
+ GibberTransportClass parent_class;
+};
+
+struct _TestTransport {
+ GibberTransport parent;
+};
+
+GType test_transport_get_type (void);
+
+/* TYPE MACROS */
+#define TEST_TYPE_TRANSPORT \
+ (test_transport_get_type ())
+#define TEST_TRANSPORT(obj) \
+ (G_TYPE_CHECK_INSTANCE_CAST((obj), TEST_TYPE_TRANSPORT, TestTransport))
+#define TEST_TRANSPORT_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_TRANSPORT, TestTransportClass))
+#define TEST_IS_TRANSPORT(obj) \
+ (G_TYPE_CHECK_INSTANCE_TYPE((obj), TEST_TYPE_TRANSPORT))
+#define TEST_IS_TRANSPORT_CLASS(klass) \
+ (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_TRANSPORT))
+#define TEST_TRANSPORT_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_TRANSPORT, TestTransportClass))
+
+typedef gboolean (*test_transport_send_hook)(GibberTransport *transport,
+ const guint8 *data,
+ gsize length,
+ GError **error,
+ gpointer user_data);
+TestTransport *test_transport_new (test_transport_send_hook send,
+ gpointer user_data);
+
+void test_transport_set_echoing (TestTransport *transport,
+ gboolean echo);
+
+void test_transport_write (TestTransport *transport,
+ const guint8 *buf, gsize size);
+
+G_END_DECLS
+
+#endif /* #ifndef __TEST_TRANSPORT_H__*/
diff --git a/lib/gibber/tests/test-xmpp-connection.c b/lib/gibber/tests/test-xmpp-connection.c
new file mode 100644
index 0000000..71e5e2b
--- /dev/null
+++ b/lib/gibber/tests/test-xmpp-connection.c
@@ -0,0 +1,157 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <glib.h>
+
+#include <gibber/gibber-xmpp-connection.h>
+#include <gibber/gibber-transport.h>
+#include "test-transport.h"
+
+#define BUFSIZE 10
+
+FILE *treefile = NULL;
+FILE *xmlfile = NULL;
+gboolean parsing_failed = FALSE;
+
+static gboolean
+send_hook (GibberTransport *transport, const guint8 *data,
+ gsize length, GError **error, gpointer user_data)
+{
+ size_t written;
+ /* Nothing for now */
+ written = fwrite (data, 1, length, xmlfile);
+ g_assert (written == length);
+ return TRUE;
+}
+
+static void
+parse_error (GibberXmppConnection *connection, gpointer user_data)
+{
+ fprintf (treefile, "PARSE ERROR\n");
+ fprintf (stderr, "PARSING FAILED\n");
+ parsing_failed = TRUE;
+}
+
+static void
+stream_opened (GibberXmppConnection *connection, const gchar *to,
+ const gchar *from, const gchar *version, gpointer user_data)
+{
+ fprintf (treefile, "STREAM OPENED to=%s from=%s version=%s\n", to, from,
+ version);
+
+ gibber_xmpp_connection_open (connection, to, from, version);
+}
+
+static void
+stream_closed (GibberXmppConnection *connection, gpointer user_data)
+{
+ fprintf (treefile, "STREAM CLOSED\n");
+ gibber_xmpp_connection_close (connection);
+}
+
+static gboolean
+print_attribute (const gchar *key, const gchar *value, const gchar *ns,
+ gpointer user_data)
+{
+ fprintf (treefile, "%*s |-- Attribute: %s -> %s (ns: %s)\n",
+ GPOINTER_TO_INT (user_data), " ", key, value, ns);
+ return TRUE;
+}
+
+static void print_node (GibberXmppNode *node, gint ident);
+
+static gboolean
+print_child (GibberXmppNode *node, gpointer user_data)
+{
+ print_node (node, GPOINTER_TO_INT(user_data));
+ return TRUE;
+}
+
+static void
+print_node (GibberXmppNode *node, gint ident)
+{
+ fprintf (treefile, "%*s`-+-- Name: %s (ns: %s)\n", ident - 1, " ",
+ node->name, gibber_xmpp_node_get_ns (node));
+ gibber_xmpp_node_each_attribute (node, print_attribute,
+ GINT_TO_POINTER(ident));
+
+ if (node->content)
+ fprintf (treefile, "%*s |-- Content: %s\n", ident, " ", node->content);
+ if (gibber_xmpp_node_get_language (node))
+ fprintf (treefile, "%*s |-- Language: %s\n", ident, " ",
+ gibber_xmpp_node_get_language (node));
+
+ gibber_xmpp_node_each_child (node, print_child, GINT_TO_POINTER (ident + 2));
+}
+
+static void
+received_stanza (GibberXmppConnection *connection, GibberXmppStanza *stanza,
+ gpointer user_data)
+{
+ fprintf (treefile, "-|\n");
+ print_node (stanza->node, 2);
+ g_assert (gibber_xmpp_connection_send (connection, stanza, NULL));
+}
+
+int
+main (int argc, char **argv)
+{
+ GibberXmppConnection *connection;
+ TestTransport *transport;
+ FILE *file;
+ int ret = 0;
+ guint8 buf[BUFSIZE];
+
+
+ g_type_init ();
+
+ transport = test_transport_new (send_hook, NULL);
+ connection = gibber_xmpp_connection_new (GIBBER_TRANSPORT(transport));
+
+ g_signal_connect (connection, "parse-error",
+ G_CALLBACK (parse_error), NULL);
+ g_signal_connect (connection, "stream-opened",
+ G_CALLBACK (stream_opened), NULL);
+ g_signal_connect (connection, "stream-closed",
+ G_CALLBACK (stream_closed), NULL);
+ g_signal_connect (connection, "received-stanza",
+ G_CALLBACK (received_stanza), NULL);
+
+ g_assert (argc >= 2 && argc < 5);
+
+ file = fopen (argv[1], "r");
+ g_assert (file != NULL);
+
+ if (argc >= 3)
+ {
+ treefile = fopen (argv[2], "w+");
+ }
+ else
+ {
+ treefile = stdout;
+ }
+ g_assert (treefile != NULL);
+
+ if (argc >= 4)
+ {
+ xmlfile = fopen (argv[3], "w+");
+ }
+ else
+ {
+ xmlfile = stderr;
+ }
+ g_assert (xmlfile != NULL);
+
+ while (!parsing_failed && (ret = fread (buf, 1, BUFSIZE, file)) > 0)
+ {
+ test_transport_write (transport, buf, ret);
+ }
+
+ while (g_main_context_iteration (NULL, FALSE))
+ ;
+
+
+ g_assert (parsing_failed || ret == 0);
+ fclose (file);
+
+ return parsing_failed ? 1 : 0;
+}
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 93cda48..405e3b7 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -10,15 +10,6 @@ $(top_builddir)/lib/gibber/libgibber.la:
.PHONY: $(top_builddir)/lib/gibber/libgibber.la
-TESTS = \
- run-xmpp-connection-test.sh
-
-check_PROGRAMS = \
- test-xmpp-connection \
- test-r-multicast-transport-io
-
-check_SCRIPTS = run-xmpp-connection-test.sh
-
EXTRA_DIST = simplemeshtest.py mesh.py $(check_SCRIPTS)
noinst_PROGRAMS = \
@@ -34,57 +25,15 @@ telepathy_salut_debug_LDADD = \
$(top_builddir)/extensions/libsalut-extensions.la \
-ltelepathy-glib
-test_xmpp_connection_SOURCES = \
- test-xmpp-connection.c \
- test-transport.c \
- test-transport.h
-
-test_xmpp_connection_LDADD = \
- $(top_builddir)/lib/gibber/libgibber.la \
- $(AM_LDFLAGS)
-
-test_xmpp_connection_CFLAGS = \
- $(AM_CFLAGS)
-
-test_r_multicast_transport_io_SOURCES = \
- test-r-multicast-transport-io.c \
- test-transport.c \
- test-transport.h
-
-test_r_multicast_transport_io_LDADD = \
- $(top_builddir)/lib/gibber/libgibber.la \
- $(AM_LDFLAGS)
-
-test_r_multicast_transport_io_CFLAGS = \
- $(AM_CFLAGS)
-
-
if HAVE_CHECK
-check_PROGRAMS += check-main
-TESTS += check-main
+check_PROGRAMS = check-main
+TESTS = check-main
check_main_SOURCES = \
check-main.c \
check-helpers.c \
check-helpers.h \
- check-gibber.h \
- check-salut.h \
- check-gibber-xmpp-node.c \
- check-gibber-xmpp-reader.c \
check-node-properties.c \
- check-gibber-r-multicast-causal-transport.c \
- check-gibber-resolver.c \
- test-resolver.c \
- test-resolver.h \
- test-transport.c \
- test-transport.h \
- check-gibber-xmpp-connection.c \
- check-gibber-r-multicast-packet.c \
- check-gibber-r-multicast-sender.c \
- check-gibber-xmpp-stanza.c \
- check-gibber-iq-helper.c \
- check-gibber-listener.c \
- check-gibber-xmpp-connection-listener.c \
- check-gibber-xmpp-error.c
+ check-salut.h
check_main_LDADD = \
@CHECK_LIBS@ \
@@ -97,16 +46,6 @@ check_main_CFLAGS = \
@CHECK_CFLAGS@ \
$(AM_CFLAGS)
-if HAVE_LIBSASL2
- check_main_SOURCES += \
- check-gibber-sasl-auth.c \
- test-sasl-auth-server.c \
- test-sasl-auth-server.h
-
- check_main_LDADD += @LIBSASL2_LIBS@
- check_main_CFLAGS += @LIBSASL2_CFLAGS@
-endif
-
endif
AM_CFLAGS = $(ERROR_CFLAGS) @GLIB_CFLAGS@ @LIBXML2_CFLAGS@ @DBUS_CFLAGS@ \
@@ -130,11 +69,7 @@ endif
include $(top_srcdir)/tools/check-coding-style.mk
check-local: check-coding-style
-clean-local:
- -rm -rf outputs
- -rm -f sasl-test.db
-
-SUBDIRS = inputs twisted
+SUBDIRS = twisted
$(check_SCRIPTS): always-run
chmod +x $(srcdir)/$@
diff --git a/tests/check-gibber-iq-helper.c b/tests/check-gibber-iq-helper.c
deleted file mode 100644
index 5a79c45..0000000
--- a/tests/check-gibber-iq-helper.c
+++ /dev/null
@@ -1,432 +0,0 @@
-/*
- * check-gibber-iq-helper.c - Test for GibberIqHelper
- * Copyright (C) 2007 Collabora Ltd.
- * @author Guillaume Desmottes <guillaume.desmottes at collabora.co.uk>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <dbus/dbus-glib.h>
-
-#include <gibber/gibber-xmpp-stanza.h>
-#include <gibber/gibber-iq-helper.h>
-#include <gibber/gibber-xmpp-error.h>
-#include <gibber/gibber-namespaces.h>
-
-#include <check.h>
-#include "check-helpers.h"
-#include "check-gibber.h"
-
-#include "test-transport.h"
-
-gboolean received_reply = FALSE;
-
-static gboolean
-send_hook (GibberTransport *transport,
- const guint8 *data,
- gsize length,
- GError **error,
- gpointer user_data)
-{
- test_transport_write (TEST_TRANSPORT (transport), data, length);
- return TRUE;
-}
-
-static GibberXmppConnection *
-create_xmpp_connection (void)
-{
- GibberXmppConnection *xmpp_connection;
- TestTransport *transport;
-
- transport = test_transport_new (send_hook, NULL);
- xmpp_connection = gibber_xmpp_connection_new (GIBBER_TRANSPORT (transport));
- gibber_xmpp_connection_open (xmpp_connection, "to", "from", "1.0");
-
- g_object_unref (transport);
-
- return xmpp_connection;
-}
-
-START_TEST (test_iq_helper_new)
-{
- GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
- GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
- fail_unless (iq_helper != NULL);
- g_object_unref (xmpp_connection);
- g_object_unref (iq_helper);
-}
-END_TEST
-
-static void
-reply_func (GibberIqHelper *helper,
- GibberXmppStanza *sent_stanza,
- GibberXmppStanza *reply_stanza,
- GObject *object,
- gpointer user_data)
-{
- received_reply = TRUE;
-}
-
-static void
-send_stanza_and_reply (GibberXmppConnection *xmpp_connection,
- GibberIqHelper *iq_helper,
- GibberXmppStanza *stanza,
- GibberXmppStanza *reply)
-{
- gboolean result;
-
- if (stanza != NULL)
- {
- result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
- NULL, NULL, NULL);
- fail_unless (result);
- }
-
- if (reply != NULL)
- {
- result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
- fail_unless (result);
- }
-
- while (g_main_context_iteration (NULL, FALSE))
- ;
-
-}
-
-START_TEST (test_send_with_reply)
-{
- GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
- GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
- GibberXmppStanza *stanza, *reply;
-
- received_reply = FALSE;
-
- stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
- GIBBER_STANZA_SUB_TYPE_SET,
- "from", "to",
- GIBBER_NODE_ATTRIBUTE, "id", "69",
- GIBBER_STANZA_END);
-
- /* Reply of the stanza */
- reply = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
- GIBBER_STANZA_SUB_TYPE_RESULT,
- "to", "from",
- GIBBER_NODE_ATTRIBUTE, "id", "69",
- GIBBER_STANZA_END);
-
- send_stanza_and_reply (xmpp_connection, iq_helper, stanza, reply);
- fail_unless (received_reply);
-
- g_object_unref (stanza);
- g_object_unref (reply);
- g_object_unref (xmpp_connection);
- g_object_unref (iq_helper);
-}
-END_TEST
-
-START_TEST (test_send_without_reply)
-{
- GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
- GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
- GibberXmppStanza *stanza;
-
- received_reply = FALSE;
-
- stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
- GIBBER_STANZA_SUB_TYPE_SET,
- "from", "to",
- GIBBER_NODE_ATTRIBUTE, "id", "69",
- GIBBER_STANZA_END);
-
- send_stanza_and_reply (xmpp_connection, iq_helper, stanza, NULL);
- fail_unless (!received_reply);
-
- g_object_unref (stanza);
- g_object_unref (xmpp_connection);
- g_object_unref (iq_helper);
-}
-END_TEST
-
-START_TEST (test_send_with_bad_reply_type)
-{
- GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
- GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
- GibberXmppStanza *stanza, *reply;
-
- received_reply = FALSE;
-
- stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
- GIBBER_STANZA_SUB_TYPE_SET,
- "from", "to",
- GIBBER_NODE_ATTRIBUTE, "id", "69",
- GIBBER_STANZA_END);
-
- /* Reply can't be of sub type "get" */
- reply = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
- GIBBER_STANZA_SUB_TYPE_GET,
- "to", "from",
- GIBBER_NODE_ATTRIBUTE, "id", "69",
- GIBBER_STANZA_END);
-
- send_stanza_and_reply (xmpp_connection, iq_helper, stanza, reply);
- fail_unless (!received_reply);
-
- g_object_unref (stanza);
- g_object_unref (reply);
- g_object_unref (xmpp_connection);
- g_object_unref (iq_helper);
-}
-END_TEST
-
-START_TEST (test_send_without_id)
-{
- GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
- GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
- GibberXmppStanza *stanza, *reply;
- gboolean result;
- const gchar *id;
-
- received_reply = FALSE;
-
- stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
- GIBBER_STANZA_SUB_TYPE_SET,
- "from", "to",
- GIBBER_STANZA_END);
-
- result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
- NULL, NULL, NULL);
- fail_unless (result);
-
- /* gibber_iq_helper_send_with_reply generated an id */
- id = gibber_xmpp_node_get_attribute (stanza->node, "id");
-
- reply = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
- GIBBER_STANZA_SUB_TYPE_RESULT,
- "to", "from",
- GIBBER_NODE_ATTRIBUTE, "id", id,
- GIBBER_STANZA_END);
-
- result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
- fail_unless (result);
-
- while (g_main_context_iteration (NULL, FALSE))
- ;
-
- fail_unless (received_reply);
-
- g_object_unref (stanza);
- g_object_unref (reply);
- g_object_unref (xmpp_connection);
- g_object_unref (iq_helper);
-}
-END_TEST
-
-START_TEST (test_new_result_reply)
-{
- GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
- GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
- GibberXmppStanza *stanza, *reply;
- gboolean result;
-
- received_reply = FALSE;
-
- stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
- GIBBER_STANZA_SUB_TYPE_SET,
- "from", "to",
- GIBBER_STANZA_END);
-
- result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
- NULL, NULL, NULL);
- fail_unless (result);
-
- reply = gibber_iq_helper_new_result_reply (stanza);
- fail_unless (reply != NULL);
- fail_unless (strcmp (reply->node->name, "iq") == 0);
- fail_unless (strcmp (gibber_xmpp_node_get_attribute (reply->node, "type"),
- "result") == 0);
- result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
- fail_unless (result);
-
- while (g_main_context_iteration (NULL, FALSE))
- ;
-
- fail_unless (received_reply);
-
- g_object_unref (stanza);
- g_object_unref (reply);
- g_object_unref (xmpp_connection);
- g_object_unref (iq_helper);
-}
-END_TEST
-
-START_TEST (test_new_error_reply)
-{
- GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
- GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
- GibberXmppStanza *stanza, *reply;
- GibberXmppNode *error_node, *node;
- gboolean result;
-
- received_reply = FALSE;
-
- stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
- GIBBER_STANZA_SUB_TYPE_SET,
- "from", "to",
- GIBBER_STANZA_END);
-
- result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
- NULL, NULL, NULL);
- fail_unless (result);
-
- reply = gibber_iq_helper_new_error_reply (stanza,
- XMPP_ERROR_BAD_REQUEST, "test");
- fail_unless (reply != NULL);
- fail_unless (strcmp (reply->node->name, "iq") == 0);
- fail_unless (strcmp (gibber_xmpp_node_get_attribute (reply->node, "type"),
- "error") == 0);
-
- error_node = gibber_xmpp_node_get_child (reply->node, "error");
- fail_if (error_node == NULL);
- fail_if (strcmp (gibber_xmpp_node_get_attribute (error_node, "code"),
- "400") != 0);
- fail_if (strcmp (gibber_xmpp_node_get_attribute (error_node, "type"),
- "modify") != 0);
-
- node = gibber_xmpp_node_get_child_ns (error_node, "bad-request",
- GIBBER_XMPP_NS_STANZAS);
- fail_if (node == NULL);
-
- node = gibber_xmpp_node_get_child (error_node, "text");
- fail_if (node == NULL);
- fail_if (strcmp (node->content, "test") != 0);
-
- result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
- fail_unless (result);
-
- while (g_main_context_iteration (NULL, FALSE))
- ;
-
- fail_unless (received_reply);
-
- g_object_unref (stanza);
- g_object_unref (reply);
- g_object_unref (xmpp_connection);
- g_object_unref (iq_helper);
-}
-END_TEST
-
-START_TEST (test_send_with_object_living)
-{
- GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
- GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
- GibberXmppStanza *stanza, *reply;
- gboolean result;
- GObject *object;
-
- received_reply = FALSE;
-
- /* We don't care about the TestTransport, we just need a GObject */
- object = g_object_new (TEST_TYPE_TRANSPORT, NULL);
-
- stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
- GIBBER_STANZA_SUB_TYPE_SET,
- "from", "to",
- GIBBER_STANZA_END);
-
- result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
- object, NULL, NULL);
- fail_unless (result);
-
- reply = gibber_iq_helper_new_result_reply (stanza);
- fail_unless (reply != NULL);
- result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
- fail_unless (result);
-
- while (g_main_context_iteration (NULL, FALSE))
- ;
-
- fail_unless (received_reply);
-
- g_object_unref (stanza);
- g_object_unref (reply);
- g_object_unref (object);
- g_object_unref (xmpp_connection);
- g_object_unref (iq_helper);
-}
-END_TEST
-
-START_TEST (test_send_with_object_destroyed)
-{
- GibberXmppConnection *xmpp_connection = create_xmpp_connection ();
- GibberIqHelper *iq_helper = gibber_iq_helper_new (xmpp_connection);
- GibberXmppStanza *stanza, *reply;
- gboolean result;
- GObject *object;
-
- received_reply = FALSE;
-
- /* We don't care about the TestTransport, we just need a GObject */
- object = g_object_new (TEST_TYPE_TRANSPORT, NULL);
-
- stanza = gibber_xmpp_stanza_build (GIBBER_STANZA_TYPE_IQ,
- GIBBER_STANZA_SUB_TYPE_SET,
- "from", "to",
- GIBBER_STANZA_END);
-
- result = gibber_iq_helper_send_with_reply (iq_helper, stanza, reply_func,
- object, NULL, NULL);
- fail_unless (result);
-
- g_object_unref (object);
-
- reply = gibber_iq_helper_new_result_reply (stanza);
- fail_unless (reply != NULL);
- result = gibber_xmpp_connection_send (xmpp_connection, reply, NULL);
- fail_unless (result);
-
- while (g_main_context_iteration (NULL, FALSE))
- ;
-
- /* Object was destroyed before we send the reply so we don't receive
- * the reply */
- fail_unless (!received_reply);
-
- g_object_unref (stanza);
- g_object_unref (reply);
- g_object_unref (xmpp_connection);
- g_object_unref (iq_helper);
-}
-END_TEST
-
-TCase *
-make_gibber_iq_helper_tcase (void)
-{
- TCase *tc = tcase_create ("IQ helper");
- tcase_add_test (tc, test_iq_helper_new);
- tcase_add_test (tc, test_send_with_reply);
- tcase_add_test (tc, test_send_without_reply);
- tcase_add_test (tc, test_send_with_bad_reply_type);
- tcase_add_test (tc, test_send_without_id);
- tcase_add_test (tc, test_new_result_reply);
- tcase_add_test (tc, test_new_error_reply);
- tcase_add_test (tc, test_send_with_object_living);
- tcase_add_test (tc, test_send_with_object_destroyed);
-
- return tc;
-}
diff --git a/tests/check-gibber-listener.c b/tests/check-gibber-listener.c
deleted file mode 100644
index 4a1bce0..0000000
--- a/tests/check-gibber-listener.c
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * check-gibber-listener.c - Test for GibberListener
- * Copyright (C) 2007, 2008 Collabora Ltd.
- * @author Guillaume Desmottes <guillaume.desmottes at collabora.co.uk>
- * @author Sjoerd Simons <sjoerd.simons at collabora.co.uk>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-#include <unistd.h>
-
-#include <gibber/gibber-tcp-transport.h>
-#include <gibber/gibber-unix-transport.h>
-#include <gibber/gibber-listener.h>
-
-#include <check.h>
-#include "check-gibber.h"
-
-gboolean got_connection;
-gboolean signalled;
-
-static void
-new_connection_cb (GibberListener *listener,
- GibberTransport *connection,
- struct sockaddr *addr,
- guint size,
- GMainLoop *loop)
-{
- signalled = TRUE;
- got_connection = TRUE;
- g_main_loop_quit (loop);
-}
-
-static void
-disconnected_cb (GibberTransport *transport, GMainLoop *loop)
-{
- signalled = TRUE;
- got_connection = FALSE;
- g_main_loop_quit (loop);
-}
-
-static GibberTransport *
-connect_to_port (int port, GMainLoop *loop)
-{
- GibberTCPTransport *transport;
- gchar sport[16];
-
- g_snprintf (sport, 16, "%d", port);
-
- transport = gibber_tcp_transport_new ();
- g_signal_connect (transport, "disconnected",
- G_CALLBACK (disconnected_cb), loop);
-
- gibber_tcp_transport_connect (transport, "127.0.0.1", sport);
-
- return GIBBER_TRANSPORT (transport);
-}
-
-START_TEST (test_unix_listen)
-{
- GibberListener *listener_unix;
- GibberUnixTransport *unix_transport;
- int ret;
- GMainLoop *mainloop;
- GError *error = NULL;
- gchar *path = "/tmp/check-gibber-listener-socket";
-
- ret = unlink (path);
- fail_if (ret == -1 && errno != ENOENT);
-
- mainloop = g_main_loop_new (NULL, FALSE);
-
- listener_unix = gibber_listener_new ();
- fail_if (listener_unix == NULL);
-
- g_signal_connect (listener_unix, "new-connection",
- G_CALLBACK (new_connection_cb), mainloop);
-
- ret = gibber_listener_listen_socket (listener_unix, path, FALSE, &error);
- fail_if (ret != TRUE);
-
- unix_transport = gibber_unix_transport_new ();
- ret = gibber_unix_transport_connect (unix_transport, path, &error);
- fail_if (ret != TRUE);
-
- if (!signalled)
- g_main_loop_run (mainloop);
-
- fail_if (!got_connection, "Failed to connect");
-
- g_object_unref (listener_unix);
- g_object_unref (unix_transport);
- g_main_loop_unref (mainloop);
-} END_TEST
-
-START_TEST (test_tcp_listen)
-{
- GibberListener *listener;
- GibberListener *listener_without_port;
- GibberListener *listener2;
- int ret, port;
- GMainLoop *mainloop;
- GibberTransport *transport;
- GError *error = NULL;
-
- mainloop = g_main_loop_new (NULL, FALSE);
-
- /* tcp socket tests without a specified port */
- listener_without_port = gibber_listener_new ();
- fail_if (listener_without_port == NULL);
-
- g_signal_connect (listener_without_port, "new-connection",
- G_CALLBACK (new_connection_cb), mainloop);
-
- ret = gibber_listener_listen_tcp (listener_without_port, 0, &error);
- fail_if (ret != TRUE);
- port = gibber_listener_get_port (listener_without_port);
-
- signalled = FALSE;
- transport = connect_to_port (port, mainloop);
- if (!signalled)
- g_main_loop_run (mainloop);
-
- fail_if (!got_connection, "Failed to connect");
-
- g_object_unref (listener_without_port);
- g_object_unref (transport);
-
- /* tcp socket tests with a specified port */
- listener = gibber_listener_new ();
- fail_if (listener == NULL);
-
- g_signal_connect (listener, "new-connection", G_CALLBACK (new_connection_cb),
- mainloop);
-
- for (port = 5298; port < 5400; port++)
- {
- if (gibber_listener_listen_tcp (listener, port, &error))
- break;
-
- fail_if (!g_error_matches (error, GIBBER_LISTENER_ERROR,
- GIBBER_LISTENER_ERROR_ADDRESS_IN_USE));
- g_error_free (error);
- error = NULL;
- }
- fail_if (port >= 5400);
- fail_if (port != gibber_listener_get_port (listener));
-
- /* try a second listener on the same port */
- listener2 = gibber_listener_new ();
- fail_if (listener2 == NULL);
- fail_if (gibber_listener_listen_tcp (listener2, port, &error));
- fail_if (!g_error_matches (error, GIBBER_LISTENER_ERROR,
- GIBBER_LISTENER_ERROR_ADDRESS_IN_USE));
- g_object_unref (listener2);
- g_error_free (error);
- error = NULL;
-
- signalled = FALSE;
- transport = connect_to_port (port, mainloop);
- if (!signalled)
- g_main_loop_run (mainloop);
-
- fail_if (!got_connection, "Failed to connect");
-
- g_object_unref (listener);
- g_object_unref (transport);
-
- /* listener is destroyed, connection should be refused now */
- signalled = FALSE;
- transport = connect_to_port (port, mainloop);
-
- if (!signalled)
- g_main_loop_run (mainloop);
-
- fail_if (got_connection, "Connected while listening should have stopped");
-
- g_object_unref (transport);
- g_main_loop_unref (mainloop);
-
-} END_TEST
-
-TCase *
-make_gibber_listener_tcase (void)
-{
- TCase *tc = tcase_create ("GibberListener");
- tcase_add_test (tc, test_tcp_listen);
- tcase_add_test (tc, test_unix_listen);
- return tc;
-}
diff --git a/tests/check-gibber-r-multicast-causal-transport.c b/tests/check-gibber-r-multicast-causal-transport.c
deleted file mode 100644
index 8dc9278..0000000
--- a/tests/check-gibber-r-multicast-causal-transport.c
+++ /dev/null
@@ -1,550 +0,0 @@
-/*
- * check-gibber-r-multicast-causal-transport.c
- * - R Multicast CausalTransport test
- * Copyright (C) 2007 Collabora Ltd.
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
-
-#include <gibber/gibber-r-multicast-causal-transport.h>
-#include <gibber/gibber-r-multicast-packet.h>
-#include "test-transport.h"
-#include "check-gibber.h"
-
-#include <check.h>
-
-/* Numer of polls we expect the id generation to do */
-#define ID_GENERATION_EXPECTED_POLLS 3
-
-/* Assume mtu is 1500, we want at least 3 packets */
-#define TEST_DATA_SIZE 3300
-GMainLoop *loop;
-
-static GibberRMulticastCausalTransport *
-create_rmulticast_transport (TestTransport **testtransport,
- const gchar *name,
- test_transport_send_hook test_send_hook,
- gpointer user_data)
-{
- TestTransport *t;
- GibberRMulticastCausalTransport *rmctransport;
-
- t = test_transport_new (test_send_hook, user_data);
- fail_unless (t != NULL);
- GIBBER_TRANSPORT (t)->max_packet_size = 150;
-
- rmctransport = gibber_r_multicast_causal_transport_new
- (GIBBER_TRANSPORT(t), "test123");
- g_object_unref (t);
-
- if (testtransport != NULL)
- {
- *testtransport = t;
- }
-
- test_transport_set_echoing (t, TRUE);
-
- return rmctransport;
-}
-
-static void
-rmulticast_connect (GibberRMulticastCausalTransport *transport)
-{
-
- fail_unless (transport != NULL);
-
- fail_unless (gibber_r_multicast_causal_transport_connect (transport,
- FALSE, NULL));
-}
-
-
-/* test depends test */
-struct {
- gchar *name;
- guint32 sender_id;
- guint32 packet_id;
- gboolean seen;
-} senders[] = {
- { "test0", 1, 0xff, FALSE },
- { "test1", 2, 0xffff, FALSE },
- { "test2", 3, 0xffffff, FALSE },
- { "test3", 4, 0xaaaaaa, FALSE },
- { "test4", 5, 0xabcdab, FALSE },
- { NULL, 0, 0, FALSE }
-};
-
-static gboolean
-depends_send_hook (GibberTransport *transport,
- const guint8 *data,
- gsize length,
- GError **error,
- gpointer user_data)
-{
- GibberRMulticastPacket *packet;
- guint i, n;
-
- packet = gibber_r_multicast_packet_parse (data, length, NULL);
- fail_unless (packet != NULL);
-
- if (packet->type == PACKET_TYPE_WHOIS_REQUEST)
- {
- GibberRMulticastPacket *reply;
- guint8 *pdata;
- gsize psize;
-
- for (i = 0; senders[i].name != NULL; i++)
- {
- if (senders[i].sender_id == packet->data.whois_request.sender_id)
- {
- break;
- }
- }
-
- if (senders[i].name == NULL && packet->sender == 0)
- {
- /* unique id polling */
- goto out;
- }
-
- fail_unless (senders[i].name != NULL);
-
- reply = gibber_r_multicast_packet_new (PACKET_TYPE_WHOIS_REPLY,
- senders[i].sender_id, transport->max_packet_size);
-
- gibber_r_multicast_packet_set_whois_reply_info (reply,
- senders[i].name);
-
- pdata = gibber_r_multicast_packet_get_raw_data (reply, &psize);
- test_transport_write (TEST_TRANSPORT(transport), pdata, psize);
- g_object_unref (reply);
- }
-
- if (packet->type != PACKET_TYPE_DATA)
- {
- goto out;
- }
-
- fail_unless (packet->depends->len > 0);
-
- for (n = 0; n < packet->depends->len; n++)
- {
- for (i = 0; senders[i].name != NULL ; i++)
- {
- GibberRMulticastPacketSenderInfo *sender_info =
- g_array_index (packet->depends,
- GibberRMulticastPacketSenderInfo *, n);
- if (senders[i].sender_id == sender_info->sender_id)
- {
- fail_unless (senders[i].seen == FALSE);
- fail_unless (senders[i].packet_id + 1 == sender_info->packet_id);
- senders[i].seen = TRUE;
- break;
- }
- }
- fail_unless (senders[i].name != NULL);
- }
-
- for (i = 0; senders[i].name != NULL ; i++)
- {
- fail_unless (senders[i].seen, "Not all senders in depends");
- }
-
- g_main_loop_quit (loop);
-out:
- g_object_unref (packet);
- return TRUE;
-}
-
-static gboolean
-depends_send_test_data (gpointer data)
-{
- GibberRMulticastCausalTransport *t =
- GIBBER_R_MULTICAST_CAUSAL_TRANSPORT (data);
- guint8 testdata[] = { 1, 2, 3 };
-
- fail_unless (gibber_transport_send (GIBBER_TRANSPORT (t), testdata,
- 3, NULL));
-
- return FALSE;
-}
-
-static void
-depends_connected (GibberTransport *transport,
- gpointer user_data)
-{
- GibberRMulticastCausalTransport *rmctransport
- = GIBBER_R_MULTICAST_CAUSAL_TRANSPORT (transport);
- TestTransport *testtransport = TEST_TRANSPORT (user_data);
- int i;
-
- /* First input some data packets, so the transport is forced to generate
- * dependency info */
- for (i = 0 ; senders[i].name != NULL; i++)
- {
- GibberRMulticastPacket *packet;
- guint8 *data;
- gsize size;
-
- packet = gibber_r_multicast_packet_new (PACKET_TYPE_DATA,
- senders[i].sender_id,
- GIBBER_TRANSPORT (testtransport)->max_packet_size);
-
- gibber_r_multicast_causal_transport_add_sender (rmctransport,
- senders[i].sender_id);
- gibber_r_multicast_causal_transport_update_sender_start (rmctransport,
- senders[i].sender_id, senders[i].packet_id);
-
- gibber_r_multicast_packet_set_packet_id (packet, senders[i].packet_id);
- gibber_r_multicast_packet_set_data_info (packet, 0, 0, 1);
-
- data = gibber_r_multicast_packet_get_raw_data (packet, &size);
- test_transport_write (testtransport, data, size);
- g_object_unref (packet);
- }
-
- /* Wait more then 200 ms, so all senders can get go to running */
- g_timeout_add (300, depends_send_test_data, rmctransport);
-}
-
-START_TEST (test_depends)
-{
- GibberRMulticastCausalTransport *rmctransport;
- TestTransport *testtransport;
- int i;
-
- loop = g_main_loop_new (NULL, FALSE);
-
- rmctransport = create_rmulticast_transport (&testtransport, "test123",
- depends_send_hook, NULL);
-
- g_signal_connect (rmctransport, "connected",
- G_CALLBACK (depends_connected), testtransport);
-
- rmulticast_connect (rmctransport);
-
- g_main_loop_run (loop);
- g_main_loop_unref (loop);
-
- for (i = 0 ; senders[i].name != NULL; i++)
- {
- fail_unless (senders[i].seen);
- }
-
- g_object_unref (rmctransport);
-}
-END_TEST
-
-
-/* test fragmentation testing */
-static gboolean
-fragmentation_send_hook (GibberTransport *transport,
- const guint8 *data,
- gsize length,
- GError **error,
- gpointer user_data)
-{
- GibberRMulticastPacket *packet;
- static gsize bytes = 0;
- static guint8 next_byte = 0;
- gsize i;
- gsize size;
- guint8 *payload;
-
- packet = gibber_r_multicast_packet_parse (data, length, NULL);
- fail_unless (packet != NULL);
-
- if (packet->type != PACKET_TYPE_DATA)
- {
- goto out;
- }
-
- payload = gibber_r_multicast_packet_get_payload (packet, &size);
-
- if (bytes == 0)
- fail_unless
- (packet->data.data.flags == GIBBER_R_MULTICAST_DATA_PACKET_START);
- else if (bytes + size < TEST_DATA_SIZE)
- fail_unless (packet->data.data.flags == 0);
-
- bytes += size;
- fail_unless (bytes <= TEST_DATA_SIZE);
-
- /* check our bytes */
- for (i = 0; i < size; i++)
- {
- fail_unless (payload[i] == next_byte);
- next_byte++;
- }
-
- if (bytes == TEST_DATA_SIZE)
- {
- fail_unless
- (packet->data.data.flags == GIBBER_R_MULTICAST_DATA_PACKET_END);
- g_object_unref (packet);
- g_main_loop_quit (loop);
- return FALSE;
- }
-
-out:
- g_object_unref (packet);
- return TRUE;
-}
-
-static void
-fragmentation_connected (GibberTransport *transport,
- gpointer user_data)
-{
- GibberRMulticastCausalTransport *rmctransport
- = GIBBER_R_MULTICAST_CAUSAL_TRANSPORT (transport);
- guint8 testdata[TEST_DATA_SIZE];
- int i;
-
- for (i = 0; i < TEST_DATA_SIZE; i++)
- {
- testdata[i] = (guint8) (i & 0xff);
- }
-
- fail_unless (gibber_transport_send (GIBBER_TRANSPORT (rmctransport),
- (guint8 *) testdata, TEST_DATA_SIZE, NULL));
-}
-
-START_TEST (test_fragmentation)
-{
- GibberRMulticastCausalTransport *rmctransport;
-
- loop = g_main_loop_new (NULL, FALSE);
-
- rmctransport = create_rmulticast_transport (NULL, "test123",
- fragmentation_send_hook, NULL);
-
- g_signal_connect (rmctransport, "connected",
- G_CALLBACK (fragmentation_connected), NULL);
-
- rmulticast_connect (rmctransport);
-
- g_main_loop_run (loop);
- g_main_loop_unref (loop);
-
- g_object_unref (rmctransport);
-}
-END_TEST
-
-
-/* test unique id */
-static gboolean
-unique_id_send_hook (GibberTransport *transport,
- const guint8 *data,
- gsize length,
- GError **error,
- gpointer user_data)
-{
- GibberRMulticastPacket *packet;
- guint32 *test_id = (guint32 *) user_data;
-
-
- packet = gibber_r_multicast_packet_parse (data, length, NULL);
- fail_unless (packet != NULL);
-
- if (*test_id == 0)
- {
- /* force collision */
- GibberRMulticastPacket *reply;
- guint8 *pdata;
- gsize psize;
-
- /* First packet must be a whois request to see if the id is taken */
- fail_unless (packet->type == PACKET_TYPE_WHOIS_REQUEST);
- /* Sender must be 0 as it couldn't choose a id just yet */
- fail_unless (packet->sender == 0);
-
- *test_id = packet->data.whois_request.sender_id;
-
- reply = gibber_r_multicast_packet_new (PACKET_TYPE_WHOIS_REPLY,
- *test_id, transport->max_packet_size);
-
- gibber_r_multicast_packet_set_whois_reply_info (reply, "romeo");
-
- pdata = gibber_r_multicast_packet_get_raw_data (reply, &psize);
- test_transport_write (TEST_TRANSPORT(transport), pdata, psize);
- g_object_unref (reply);
- }
- else
- {
- fail_unless (*test_id != packet->sender);
- switch (packet->type)
- {
- case PACKET_TYPE_WHOIS_REQUEST:
- fail_unless (*test_id != packet->data.whois_request.sender_id);
- break;
- case PACKET_TYPE_WHOIS_REPLY:
- /* transport sends a unsolicited whois reply after choosing a
- * identifier */
- g_main_loop_quit (loop);
- break;
- default:
- fail ("Unexpected packet type: %x", packet->type);
- }
- }
-
- g_object_unref (packet);
- return TRUE;
-}
-
-START_TEST (test_unique_id)
-{
- /* Test if the multicast transport correctly handles the case that it gets a
- * WHOIS_REPLY on one of it's WHOIS_REQUESTS when it's determining a unique
- * id for itself */
- GibberRMulticastCausalTransport *rmctransport;
- guint32 test_id;
-
- test_id = 0;
- loop = g_main_loop_new (NULL, FALSE);
-
- rmctransport = create_rmulticast_transport (NULL, "test123",
- unique_id_send_hook, &test_id);
-
- rmulticast_connect (rmctransport);
-
- g_main_loop_run (loop);
- g_main_loop_unref (loop);
-
- g_object_unref (rmctransport);
-}
-END_TEST
-
-/* test id generation conflict */
-typedef struct {
- guint32 id;
- gint count;
- gint wait;
-} unique_id_conflict_test_t;
-
-static gboolean
-id_generation_conflict_send_hook (GibberTransport *transport,
- const guint8 *data,
- gsize length,
- GError **error,
- gpointer user_data)
-{
- GibberRMulticastPacket *packet;
- unique_id_conflict_test_t *test = (unique_id_conflict_test_t *) user_data;
-
- packet = gibber_r_multicast_packet_parse (data, length, NULL);
- fail_unless (packet != NULL);
-
- if (test->id == 0)
- {
- /* First packet must be a whois request to see if the id is taken */
- fail_unless (packet->type == PACKET_TYPE_WHOIS_REQUEST);
- /* Sender must be 0 as it couldn't choose a id just yet */
- fail_unless (packet->sender == 0);
-
- test->id = packet->data.whois_request.sender_id;
- }
-
- switch (packet->type)
- {
- case PACKET_TYPE_WHOIS_REQUEST:
- test->count++;
-
- if (test->count < test->wait)
- {
- fail_unless (test->id == packet->data.whois_request.sender_id);
- }
- else if (test->count == test->wait)
- {
- /* force collision */
- GibberRMulticastPacket *reply;
- guint8 *pdata;
- gsize psize;
-
- fail_unless (test->id == packet->data.whois_request.sender_id);
-
- reply = gibber_r_multicast_packet_new (PACKET_TYPE_WHOIS_REQUEST,
- 0, transport->max_packet_size);
-
- gibber_r_multicast_packet_set_whois_request_info (reply, test->id);
-
- pdata = gibber_r_multicast_packet_get_raw_data (reply, &psize);
- test_transport_write (TEST_TRANSPORT(transport), pdata, psize);
- g_object_unref (reply);
- }
- else if (test->count > test->wait)
- {
- fail_unless (test->id != packet->data.whois_request.sender_id);
- }
-
- break;
-
- case PACKET_TYPE_WHOIS_REPLY:
- /* transport sends a unsolicited whois reply after choosing a
- * identifier */
- fail_unless (packet->sender != test->id);
- fail_unless (test->count ==
- ID_GENERATION_EXPECTED_POLLS + test->wait);
- g_main_loop_quit (loop);
- break;
-
- default:
- fail ("Unexpected packet type: %x", packet->type);
- }
-
- g_object_unref (packet);
- return TRUE;
-}
-
-START_TEST (test_id_generation_conflict)
-{
- /* Test if the multicast transport correctly handles the case that it sees
- * another WHOIS_REQUEST on one of its WHOIS_REQUESTS when it's determining
- * a unique id for itself */
- GibberRMulticastCausalTransport *rmtransport;
- unique_id_conflict_test_t test;
-
- test.id = 0;
- test.count = 0;
- test.wait = _i + 1;
-
- loop = g_main_loop_new (NULL, FALSE);
-
- rmtransport = create_rmulticast_transport (NULL, "test123",
- id_generation_conflict_send_hook, &test);
-
- rmulticast_connect (rmtransport);
-
- g_main_loop_run (loop);
- g_main_loop_unref (loop);
-
- g_object_unref (rmtransport);
-}
-END_TEST
-
-
-TCase *
-make_gibber_r_multicast_causal_transport_tcase (void)
-{
- TCase *tc = tcase_create ("Gibber R Multicast Causal transport");
- tcase_add_test (tc, test_unique_id);
- tcase_add_loop_test (tc, test_id_generation_conflict, 0,
- ID_GENERATION_EXPECTED_POLLS);
- tcase_add_test (tc, test_fragmentation);
- tcase_add_test (tc, test_depends);
-
- return tc;
-}
diff --git a/tests/check-gibber-r-multicast-packet.c b/tests/check-gibber-r-multicast-packet.c
deleted file mode 100644
index 52bfef4..0000000
--- a/tests/check-gibber-r-multicast-packet.c
+++ /dev/null
@@ -1,228 +0,0 @@
-#include <stdio.h>
-#include <string.h>
-
-#include <gibber/gibber-r-multicast-packet.h>
-
-#include <check.h>
-#include "check-gibber.h"
-
-#define COMPARE(x) G_STMT_START { \
- fail_unless (a->x == b->x); \
-} G_STMT_END
-
-typedef struct {
- guint32 sender_id;
- guint32 packet_id;
- gboolean seen;
-} sender_t;
-
-typedef struct {
- guint32 a;
- guint32 b;
- gint32 result;
-} diff_testcase;
-
-#define NUMBER_OF_DIFF_TESTS 15
-
-START_TEST (test_r_multicast_packet_diff)
-{
- diff_testcase cases[NUMBER_OF_DIFF_TESTS] =
- { { 0, 0, 0 },
- { 10, 10, 0 },
- { 5, 10, 5 },
- { 10, 5, -5 },
- { G_MAXUINT32 - 10, 10, 21 },
- { G_MAXUINT32, 0, 1 },
- { 0 , G_MAXUINT32, -1 },
- { G_MAXUINT32, 10, 11 },
- { 10, G_MAXUINT32, -11 },
- { G_MAXUINT32/2, G_MAXUINT32, G_MAXINT32 },
- { G_MAXUINT32, G_MAXUINT32/2, -G_MAXINT32 },
- { G_MAXUINT32/2 - 1, G_MAXUINT32, G_MAXINT32 },
- { G_MAXUINT32, G_MAXUINT32/2 - 1, -G_MAXINT32 },
- { G_MAXUINT32 - 5, 5, 11 },
- { 5, G_MAXUINT32 - 5, -11 },
-
- };
-
- diff_testcase *c = cases + _i;
- gint32 result = gibber_r_multicast_packet_diff (c->a, c->b);
- fail_unless (c->result == result);
-}
-END_TEST
-
-START_TEST (test_data_packet)
-{
- GibberRMulticastPacket *a;
- GibberRMulticastPacket *b;
- guint32 sender_id = 1234;
- guint32 packet_id = 1200;
- guint8 flags = GIBBER_R_MULTICAST_DATA_PACKET_START;
- guint32 total_size = 800;
- guint16 stream_id = 56;
- guint8 *data;
- gsize len;
- guint8 *pdata;
- gsize plen;
- guint i,n;
- sender_t senders[] =
- { { 0x300, 500, FALSE }, { 0x400, 600, FALSE }, { 0, 0, FALSE } };
- gchar *payload = "1234567890";
-
- g_type_init ();
-
- a = gibber_r_multicast_packet_new (PACKET_TYPE_DATA, sender_id, 1500);
- gibber_r_multicast_packet_set_packet_id (a, packet_id);
- gibber_r_multicast_packet_set_data_info (a, stream_id, flags, total_size);
-
- for (i = 0 ; senders[i].sender_id != 0; i++)
- {
- gibber_r_multicast_packet_add_sender_info (a,
- senders[i].sender_id, senders[i].packet_id, NULL);
- }
-
- gibber_r_multicast_packet_add_payload (a, (guint8 *) payload,
- strlen (payload));
-
- data = gibber_r_multicast_packet_get_raw_data (a, &len);
-
- b = gibber_r_multicast_packet_parse (data, len, NULL);
- fail_unless (b != NULL);
-
- COMPARE (type);
- COMPARE (version);
- COMPARE (data.data.flags);
- COMPARE (data.data.total_size);
- COMPARE (packet_id);
- COMPARE (data.data.stream_id);
-
- fail_unless (a->sender == b->sender);
-
- for (n = 0 ; n < b->depends->len; n++)
- {
- for (i = 0; senders[i].sender_id != 0 ; i++)
- {
- GibberRMulticastPacketSenderInfo *s = g_array_index (b->depends,
- GibberRMulticastPacketSenderInfo *, n);
- if (senders[i].sender_id == s->sender_id)
- {
- fail_unless (senders[i].packet_id == s->packet_id);
- fail_unless (senders[i].seen == FALSE);
- senders[i].seen = TRUE;
- break;
- }
- }
-
- fail_unless (senders[i].sender_id != 0);
- }
-
- for (i = 0; senders[i].sender_id != 0 ; i++)
- {
- fail_unless (senders[i].seen == TRUE);
- }
-
-
- pdata = gibber_r_multicast_packet_get_payload (b, &plen);
- fail_unless (plen == strlen (payload));
-
- fail_unless (memcmp (payload, pdata, plen) == 0);
-
- g_object_unref (a);
- g_object_unref (b);
-} END_TEST
-
-START_TEST (test_attempt_join_packet)
-{
- GibberRMulticastPacket *a;
- GibberRMulticastPacket *b;
- guint32 sender_id = 1234;
- guint32 packet_id = 1200;
- guint8 *data;
- gsize len;
- guint i, n;
- sender_t senders[] =
- { { 0x300, 500, FALSE }, { 0x400, 600, FALSE }, { 0, 0, FALSE } };
- sender_t new_senders[] =
- { { 0x500, 0, FALSE }, { 0x600, 0, FALSE }, { 0, 0, FALSE } };
-
- g_type_init ();
-
- a = gibber_r_multicast_packet_new (PACKET_TYPE_ATTEMPT_JOIN,
- sender_id, 1500);
- gibber_r_multicast_packet_set_packet_id (a, packet_id);
-
- for (i = 0; senders[i].sender_id != 0; i++)
- {
- gibber_r_multicast_packet_add_sender_info (a,
- senders[i].sender_id, senders[i].packet_id, NULL);
- }
- for (i = 0; new_senders[i].sender_id != 0; i++)
- {
- gibber_r_multicast_packet_attempt_join_add_sender (a,
- new_senders[i].sender_id, NULL);
- }
-
- data = gibber_r_multicast_packet_get_raw_data (a, &len);
-
- b = gibber_r_multicast_packet_parse (data, len, NULL);
-
- fail_unless (b != NULL);
-
- COMPARE (type);
- COMPARE (version);
- COMPARE (packet_id);
- COMPARE (data.attempt_join.senders->len);
-
- fail_unless (a->sender == b->sender);
-
- for (n = 0; n < b->depends->len; n++)
- {
- for (i = 0; senders[i].sender_id != 0 ; i++)
- {
- GibberRMulticastPacketSenderInfo *s = g_array_index (b->depends,
- GibberRMulticastPacketSenderInfo *, n);
- if (senders[i].sender_id == s->sender_id)
- {
- fail_unless (senders[i].packet_id == s->packet_id);
- fail_unless (senders[i].seen == FALSE);
- senders[i].seen = TRUE;
- break;
- }
- }
-
- fail_unless (senders[i].sender_id != 0);
- }
-
- for (i = 0; senders[i].sender_id != 0; i++)
- {
- fail_unless (senders[i].seen == TRUE);
- }
-
- for (i = 0; new_senders[i].sender_id != 0; i++)
- {
- fail_unless (new_senders[i].sender_id ==
- g_array_index (b->data.attempt_join.senders, guint32, i));
- new_senders[i].seen = TRUE;
- break;
- }
-
- for (i = 0; new_senders[i].sender_id != 0; i++)
- {
- fail_unless (senders[i].seen == TRUE);
- }
-
- g_object_unref (a);
- g_object_unref (b);
-}
-END_TEST
-
-TCase *
-make_gibber_r_multicast_packet_tcase (void)
-{
- TCase *tc = tcase_create ("RMulticast Packet");
- tcase_add_test (tc, test_data_packet);
- tcase_add_test (tc, test_attempt_join_packet);
- tcase_add_loop_test (tc, test_r_multicast_packet_diff, 0,
- NUMBER_OF_DIFF_TESTS);
- return tc;
-}
diff --git a/tests/check-gibber-r-multicast-sender.c b/tests/check-gibber-r-multicast-sender.c
deleted file mode 100644
index b0a4c90..0000000
--- a/tests/check-gibber-r-multicast-sender.c
+++ /dev/null
@@ -1,652 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <gibber/gibber-r-multicast-sender.h>
-
-#include <check.h>
-#include "check-gibber.h"
-
-#define SENDER 4321
-#define SENDER_NAME "testsender"
-
-#define REPAIR_PACKET ((guint32)15)
-
-#define EXTRA_SEEN ((guint32)11)
-#define NR_PACKETS ((guint32)40)
-
-guint32 serial_offset;
-guint32 expected;
-
-typedef struct {
- guint32 serial_offset;
- gboolean test_seen;
-} test_t;
-
-typedef struct {
- guint32 receiver_id;
- const gchar *name;
- guint32 packet_id;
-} recv_t;
-
-GMainLoop *loop;
-recv_t receivers[] = {
- { 0x500, "sender1", 500 },
- { 0x600, "sender2", 600 },
- { 0, NULL, 0 }
-};
-
-static GibberRMulticastPacket *
-generate_packet (guint32 serial)
-{
- GibberRMulticastPacket *p;
- guint8 flags = 0;
- gint total = 1;
- gchar *payload;
- guint8 stream_id = 0;
- int i;
-
- switch (serial % 3)
- {
- case 0:
- flags = GIBBER_R_MULTICAST_DATA_PACKET_START
- | GIBBER_R_MULTICAST_DATA_PACKET_END;
- stream_id = serial % G_MAXUINT8;
- break;
- case 1:
- flags = GIBBER_R_MULTICAST_DATA_PACKET_START;
- stream_id = serial % G_MAXUINT8;
- total = 2;
- break;
- case 2:
- flags = GIBBER_R_MULTICAST_DATA_PACKET_END;
- stream_id = (serial - 1) % G_MAXUINT8;
- total = 2;
- break;
- }
-
- p = gibber_r_multicast_packet_new (PACKET_TYPE_DATA, SENDER, 1500);
-
- gibber_r_multicast_packet_set_packet_id (p, serial);
- gibber_r_multicast_packet_set_data_info (p, stream_id, flags, total * 11);
-
- for (i = 0 ; receivers[i].receiver_id != 0; i++)
- {
- gibber_r_multicast_packet_add_sender_info (p,
- receivers[i].receiver_id, receivers[i].packet_id, NULL);
- }
-
- payload = g_strdup_printf ("%010d\n", serial);
- gibber_r_multicast_packet_add_payload (p, (guint8 *) payload,
- strlen (payload));
-
- g_free (payload);
- return p;
-}
-
-static void
-data_received_cb (GibberRMulticastSender *sender, guint8 stream_id,
- guint8 *data, gsize size, gpointer user_data)
-{
- gchar *str;
- gchar **lines;
- int i;
-
- str = g_strndup ((const gchar *)data, size);
-
- lines = g_strsplit (str, "\n", 0);
- for (i = 0 ; lines[i] != NULL && *lines[i] != '\0'; i++) {
- guint32 v = atoi (lines[i]);
-
- fail_unless (v == expected);
- fail_unless ((v % G_MAXUINT8) - i == stream_id);
- expected++;
- }
- /* serial % 3 is send out in a single packet the other two together.
- * So expected can't be % 3 == 2 here */
- fail_if (expected % 3 == 2);
-
- if (expected == serial_offset + NR_PACKETS
- || expected == serial_offset + NR_PACKETS + EXTRA_SEEN) {
- g_main_loop_quit ((GMainLoop *) user_data);
- }
-
- g_strfreev (lines);
- g_free (str);
-
-}
-
-static void
-repair_request_cb (GibberRMulticastSender *sender, guint id, gpointer data)
-{
- GibberRMulticastPacket *p;
-
- fail_unless (gibber_r_multicast_packet_diff (serial_offset, id) >= 0
- || gibber_r_multicast_packet_diff (id,
- serial_offset + NR_PACKETS + EXTRA_SEEN) < 0);
-
- p = generate_packet (id);
- gibber_r_multicast_sender_push (sender, p);
- g_object_unref (p);
-}
-
-static void
-repair_message_cb (GibberRMulticastSender *sender,
- GibberRMulticastPacket *packet, gpointer user_data)
-{
-
- fail_unless (packet->type == PACKET_TYPE_DATA);
- fail_unless (packet->packet_id == REPAIR_PACKET + serial_offset);
-
- g_main_loop_quit ((GMainLoop *) user_data);
-}
-
-static gboolean
-add_packet (gpointer data)
-{
- static guint32 i = 0;
- GibberRMulticastSender *sender = GIBBER_R_MULTICAST_SENDER (data);
- GibberRMulticastPacket *p;
-
- if (i == NR_PACKETS)
- {
- i = 0;
- return FALSE;
- }
-
- if (i % 5 != 3)
- {
- p = generate_packet (i + serial_offset);
- gibber_r_multicast_sender_push (sender, p);
- g_object_unref (p);
- }
-
- i++;
- return TRUE;
-}
-
-
-#define NUMBER_OF_TESTS 3
-
-START_TEST (test_sender)
-{
- GibberRMulticastSender *s;
- GibberRMulticastSenderGroup *group;
- test_t tests[NUMBER_OF_TESTS] = {
- { (guint32)(~0 - NR_PACKETS/2), TRUE },
- { 0xff, TRUE },
- { 0xff, FALSE },
- };
- int i;
-
- g_type_init ();
- group = gibber_r_multicast_sender_group_new ();
- loop = g_main_loop_new (NULL, FALSE);
-
- serial_offset = tests[_i].serial_offset;
- expected = serial_offset;
-
- for (i = 0 ; receivers[i].receiver_id != 0; i++)
- {
- s = gibber_r_multicast_sender_new (receivers[i].receiver_id,
- receivers[i].name, group);
- gibber_r_multicast_sender_update_start (s, receivers[i].packet_id);
- gibber_r_multicast_sender_seen (s, receivers[i].packet_id + 1);
- gibber_r_multicast_sender_group_add (group, s);
- }
-
- s = gibber_r_multicast_sender_new (SENDER, SENDER_NAME, group);
- g_signal_connect (s, "received-data", G_CALLBACK(data_received_cb), loop);
- g_signal_connect (s, "repair-request", G_CALLBACK(repair_request_cb), loop);
-
- gibber_r_multicast_sender_update_start (s, serial_offset);
- gibber_r_multicast_sender_set_data_start (s, serial_offset);
-
- if (tests[_i].test_seen)
- {
- gibber_r_multicast_sender_seen (s, serial_offset);
- }
- else
- {
- gibber_r_multicast_sender_repair_request (s, serial_offset);
- }
-
- g_timeout_add (10, add_packet, s);
-
- g_main_loop_run (loop);
-
- /* tell the sender we've seen some extra pakcets */
- gibber_r_multicast_sender_seen (s, serial_offset + NR_PACKETS + EXTRA_SEEN);
- g_main_loop_run (loop);
-
- /* Ask for a repair */
- g_signal_connect (s, "repair-message", G_CALLBACK (repair_message_cb), loop);
-
- gibber_r_multicast_sender_repair_request (s, serial_offset + REPAIR_PACKET);
-
- g_main_loop_run (loop);
-
- gibber_r_multicast_sender_group_free (group);
-} END_TEST
-
-/* Holding test */
-guint32 idle_timer = 0;
-
-typedef struct {
- gchar *name;
- guint32 packet_id;
- GibberRMulticastPacketType packet_type;
- gchar *data;
- gchar *depend_node;
- guint32 depend_packet_id;
- guint16 data_stream_id;
- guint8 flags;
- guint32 total_size;
-} h_setup_t;
-
-typedef enum {
- EXPECT = 0,
- START_DATA,
- FAIL,
- HOLD,
- UNHOLD,
- UNHOLD_IMMEDIATE,
- DONE
-} h_expect_type_t;
-
-typedef struct {
- h_expect_type_t type;
- gchar *expected_node;
- GibberRMulticastPacketType packet_type;
- guint32 hold_id;
- guint32 data_stream_id;
-} h_expect_t;
-
-typedef struct {
- int test_step;
- GibberRMulticastSenderGroup *group;
- h_expect_t *expectation;
-} h_data_t;
-
-typedef struct {
- h_setup_t *setup;
- h_expect_t *expectation;
-} h_test_t;
-
-static void h_next_test_step (h_data_t *d);
-
-static gboolean
-h_find_sender (gpointer key, gpointer value, gpointer user_data)
-{
- GibberRMulticastSender *s = GIBBER_R_MULTICAST_SENDER (value);
-
- return strcmp (s->name, (gchar *) user_data) == 0;
-}
-
-static gboolean
-h_idle_next_step (gpointer user_data)
-{
- h_data_t *d = (h_data_t *) user_data;
- h_expect_t *e = &(d->expectation[d->test_step]);
- GibberRMulticastSender *s;
-
- idle_timer = 0;
-
- switch (e->type) {
- case UNHOLD_IMMEDIATE:
- case START_DATA:
- case FAIL:
- case EXPECT:
- fail ("Should not be reached");
- break;
- case HOLD:
- s = g_hash_table_find (d->group->senders,
- h_find_sender, e->expected_node);
- fail_unless (s != NULL);
- d->test_step++;
- gibber_r_multicast_sender_hold_data (s, e->hold_id);
- h_next_test_step (d);
- break;
- case UNHOLD:
- s = g_hash_table_find (d->group->senders,
- h_find_sender, e->expected_node);
- fail_unless (s != NULL);
- d->test_step++;
- gibber_r_multicast_sender_release_data (s);
- h_next_test_step (d);
- break;
- case DONE:
- /* And there was great rejoice */
- g_main_loop_quit (loop);
- break;
- }
-
- return FALSE;
-}
-
-static void
-h_next_test_step (h_data_t *d)
-{
- GibberRMulticastSender *s;
- h_expect_t *e = &(d->expectation[d->test_step]);
-
- switch (d->expectation[d->test_step].type) {
- case EXPECT:
- break;
- case UNHOLD_IMMEDIATE:
- s = g_hash_table_find (d->group->senders,
- h_find_sender, e->expected_node);
- fail_unless (s != NULL);
- d->test_step++;
- gibber_r_multicast_sender_release_data (s);
- h_next_test_step (d);
- break;
- case START_DATA:
- s = g_hash_table_find (d->group->senders,
- h_find_sender, e->expected_node);
- fail_unless (s != NULL);
- d->test_step++;
- gibber_r_multicast_sender_set_data_start (s, e->hold_id);
- h_next_test_step (d);
- break;
- case FAIL:
- s = g_hash_table_find (d->group->senders,
- h_find_sender, e->expected_node);
- fail_unless (s != NULL);
- d->test_step++;
- gibber_r_multicast_sender_set_failed (s);
- h_next_test_step (d);
- break;
- case HOLD:
- case UNHOLD:
- case DONE:
- if (idle_timer == 0)
- {
- idle_timer = g_idle_add (h_idle_next_step, d);
- }
- }
-}
-
-static void
-h_received_data_cb (GibberRMulticastSender *sender, guint16 stream_id,
- guint8 *data, gsize size, gpointer user_data)
-{
- h_data_t *d = (h_data_t *) user_data;
-
- fail_unless (d->expectation[d->test_step].type == EXPECT);
- fail_unless (d->expectation[d->test_step].packet_type == PACKET_TYPE_DATA);
- fail_unless (
- strcmp (d->expectation[d->test_step].expected_node, sender->name) == 0);
- fail_unless (d->expectation[d->test_step].data_stream_id == stream_id);
-
- d->test_step++;
- h_next_test_step (d);
-}
-
-static void
-h_received_control_packet_cb (GibberRMulticastSender *sender,
- GibberRMulticastPacket *packet, gpointer user_data)
-{
- h_data_t *d = (h_data_t *) user_data;
-
- fail_unless (d->expectation[d->test_step].type == EXPECT);
- fail_unless (d->expectation[d->test_step].packet_type == packet->type);
- fail_unless (
- strcmp (d->expectation[d->test_step].expected_node, sender->name) == 0);
-
- d->test_step++;
- h_next_test_step (d);
-}
-
-h_setup_t h_setup0[] = {
- { "node0", 0x1, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 3, 3 },
- { "node1", 0x1, PACKET_TYPE_DATA, "001", "node0", 0x2, 0, 3, 3 },
- { "node0", 0x2, PACKET_TYPE_DATA, "002", "node1", 0x2, 0, 3, 3 },
- { "node1", 0x2, PACKET_TYPE_DATA, "002", "node0", 0x3, 0, 3, 3 },
- { "node0", 0x3, PACKET_TYPE_ATTEMPT_JOIN, NULL, "node1", 0x3 },
- { "node1", 0x3, PACKET_TYPE_ATTEMPT_JOIN, NULL, "node0", 0x4 },
- { "node0", 0x4, PACKET_TYPE_DATA, "003", "node1", 0x4, 0, 3, 3 },
- { "node1", 0x4, PACKET_TYPE_DATA, "003", "node0", 0x5, 0, 3, 3 },
- { "node0", 0x5, PACKET_TYPE_JOIN, NULL, "node1", 0x5 },
- { "node1", 0x5, PACKET_TYPE_JOIN, NULL, "node0", 0x6 },
- { NULL },
- };
-
-h_expect_t h_expectation0[] = {
- { EXPECT, "node0", PACKET_TYPE_ATTEMPT_JOIN },
- { EXPECT, "node1", PACKET_TYPE_ATTEMPT_JOIN },
- { EXPECT, "node0", PACKET_TYPE_JOIN },
- { EXPECT, "node1", PACKET_TYPE_JOIN },
- /* Set the data start of node1 to 0x1, which means all the data should still
- * be popped off */
- { START_DATA, "node1", PACKET_TYPE_INVALID, 0x1 },
- { START_DATA, "node0", PACKET_TYPE_INVALID, 0x1 },
- /* only unhold node1, nothing should happen as they depend on those of
- * node0 */
- { HOLD, "node1", PACKET_TYPE_INVALID, 0x3 },
- /* unhold node0 too, packets should start flowing */
- { HOLD, "node0", PACKET_TYPE_INVALID, 0x3 },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 0 },
- { EXPECT, "node1", PACKET_TYPE_DATA, 0, 0 },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 0 },
- { EXPECT, "node1", PACKET_TYPE_DATA, 0, 0 },
- { UNHOLD, "node1" },
- { UNHOLD, "node0" },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 0 },
- { EXPECT, "node1", PACKET_TYPE_DATA, 0, 0 },
- { DONE },
-};
-
-h_setup_t h_setup1[] = {
- { "node0", 0x1, PACKET_TYPE_ATTEMPT_JOIN, "001", "node1", 0x2 },
- { "node1", 0x1, PACKET_TYPE_ATTEMPT_JOIN, "001", NULL },
- { NULL },
-};
-
-h_expect_t h_expectation1[] = {
- { EXPECT, "node1", PACKET_TYPE_ATTEMPT_JOIN },
- { EXPECT, "node0", PACKET_TYPE_ATTEMPT_JOIN },
- { DONE }
-};
-
-h_setup_t h_setup2[] = {
- { "node0", 0x1, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 1, 9 },
- { "node0", 0x3, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 0, 9 },
- { "node0", 0x6, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 2, 9 },
- { "node0", 0x2, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 1, 6 },
- { "node0", 0x4, PACKET_TYPE_DATA, "001", NULL, 0x0, 2, 3, 3 },
- { "node0", 0x5, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 2, 6 },
- { NULL },
-};
-
-h_expect_t h_expectation2[] = {
- { START_DATA, "node0", PACKET_TYPE_INVALID, 0x1 },
- { UNHOLD, "node0" },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 2 },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 1 },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 0 },
- { DONE }
-};
-
-h_setup_t h_setup3[] = {
- { "node0", 0x1, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 1, 9 },
- { "node0", 0x2, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 1, 6 },
- { "node0", 0x3, PACKET_TYPE_ATTEMPT_JOIN, NULL, NULL },
- { "node0", 0x4, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 0, 9 },
- { "node0", 0x5, PACKET_TYPE_DATA, "001", NULL, 0x0, 2, 3, 3 },
- { "node0", 0x6, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 2, 6 },
- { "node0", 0x7, PACKET_TYPE_ATTEMPT_JOIN, NULL, NULL },
- { "node0", 0x8, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 2, 9 },
- { NULL },
-};
-
-h_expect_t h_expectation3[] = {
- { EXPECT, "node0", PACKET_TYPE_ATTEMPT_JOIN },
- { START_DATA, "node0", PACKET_TYPE_INVALID, 0x1 },
- { UNHOLD_IMMEDIATE, "node0" },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 2 },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 1 },
- { EXPECT, "node0", PACKET_TYPE_ATTEMPT_JOIN },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 0 },
- { DONE }
-};
-
-h_setup_t h_setup4[] = {
- { "node0", 0x1, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 1, 9 },
- { "node0", 0x2, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 1, 6 },
- { "node0", 0x3, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 0, 9 },
- { "node0", 0x4, PACKET_TYPE_DATA, "001", NULL, 0x0, 2, 3, 3 },
- { "node0", 0x5, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 2, 6 },
- { "node0", 0x6, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 2, 9 },
- { NULL },
-};
-
-h_expect_t h_expectation4[] = {
- { START_DATA, "node0", PACKET_TYPE_INVALID, 0x2 },
- { UNHOLD, "node0" },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 2 },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 1 },
- { DONE }
-};
-
-/* Test if failing a node correctly pops the minimum amount of packets needed
- * to fulfill all dependencies */
-h_setup_t h_setup5[] = {
- { "node1", 0x1, PACKET_TYPE_DATA, "001", NULL, 0x0, 1, 3, 3 },
- { "node1", 0x2, PACKET_TYPE_DATA, "001", "node0", 0x3, 2, 3, 3 },
-
- /* As the very first thing do a Control packet, which isn't hold back. To
- * force the setting of FAIL (as the setup instructions are run as soon as
- * the join packet is received) */
- { "node0", 0x1, PACKET_TYPE_JOIN, "001", NULL },
- { "node0", 0x2, PACKET_TYPE_DATA, "001", "node1", 0x2, 2, 3, 3 },
- { "node0", 0x3, PACKET_TYPE_DATA, "001", NULL, 0x0, 0, 3, 3 },
- { NULL },
-};
-
-h_expect_t h_expectation5[] = {
- { EXPECT, "node0", PACKET_TYPE_JOIN, 0, 1 },
- { START_DATA, "node0", PACKET_TYPE_INVALID, 0x1 },
- { START_DATA, "node1", PACKET_TYPE_INVALID, 0x1 },
- { FAIL, "node0", PACKET_TYPE_INVALID, 0x2 },
- { UNHOLD, "node0" },
- { UNHOLD, "node1" },
- { EXPECT, "node1", PACKET_TYPE_DATA, 0, 1 },
- { EXPECT, "node0", PACKET_TYPE_DATA, 0, 2 },
- { EXPECT, "node1", PACKET_TYPE_DATA, 0, 2 },
- { DONE }
-};
-
-#define NUMBER_OF_H_TESTS 6
-h_test_t h_tests[NUMBER_OF_H_TESTS] = {
- { h_setup0, h_expectation0 },
- { h_setup1, h_expectation1 },
- { h_setup2, h_expectation2 },
- { h_setup3, h_expectation3 },
- { h_setup4, h_expectation4 },
- { h_setup5, h_expectation5 },
- };
-
-
-static void
-add_h_sender (guint32 sender, gchar *name, GibberRMulticastSenderGroup *group,
- guint32 packet_id, h_data_t *data)
-{
- GibberRMulticastSender *s;
-
- s = gibber_r_multicast_sender_new (sender, name, group);
- gibber_r_multicast_sender_update_start (s, packet_id);
- gibber_r_multicast_sender_hold_data (s, packet_id);
- gibber_r_multicast_sender_group_add (group, s);
-
- g_signal_connect (s, "received-data",
- G_CALLBACK (h_received_data_cb), data);
- g_signal_connect (s, "received-control-packet",
- G_CALLBACK (h_received_control_packet_cb), data);
-}
-
-START_TEST (test_holding) {
- GibberRMulticastSenderGroup *group;
- guint32 sender_offset = 0xf00;
- /* control packets aren't hold back, thus we get them interleaved at first
- */
- h_test_t *test = h_tests + _i;
- h_data_t data = { 0, NULL, test->expectation };
- int i;
-
- g_type_init ();
- loop = g_main_loop_new (NULL, FALSE);
-
- group = gibber_r_multicast_sender_group_new ();
- data.group = group;
-
- for (i = 0; test->setup[i].name != NULL; i++)
- {
- GibberRMulticastSender *s;
- s = g_hash_table_find (group->senders,
- h_find_sender, test->setup[i].name);
- if (s == NULL)
- {
- add_h_sender (sender_offset++, test->setup[i].name, group,
- test->setup[i].packet_id, &data);
- }
- }
-
- for (i = 0; test->setup[i].name != NULL; i++)
- {
- GibberRMulticastSender *s0, *s1 = NULL;
- GibberRMulticastPacket *p;
-
- s0 = g_hash_table_find (group->senders, h_find_sender,
- test->setup[i].name);
- fail_unless (s0 != NULL);
-
- p = gibber_r_multicast_packet_new (test->setup[i].packet_type, s0->id,
- 1500);
- gibber_r_multicast_packet_set_packet_id (p, test->setup[i].packet_id);
-
- if (test->setup[i].depend_node != NULL)
- {
- s1 = g_hash_table_find (group->senders, h_find_sender,
- test->setup[i].depend_node);
- fail_unless (s1 != NULL);
- fail_unless (gibber_r_multicast_packet_add_sender_info (p, s1->id,
- test->setup[i].depend_packet_id, NULL));
- }
- if (test->setup[i].packet_type == PACKET_TYPE_DATA)
- {
- fail_unless (test->setup[i].data != NULL);
-
- gibber_r_multicast_packet_set_data_info (p,
- test->setup[i].data_stream_id,
- test->setup[i].flags,
- test->setup[i].total_size);
- gibber_r_multicast_packet_add_payload (p,
- (guint8 *) test->setup[i].data, strlen (test->setup[i].data));
- }
- gibber_r_multicast_sender_push (s0, p);
-
- g_object_unref (p);
- }
-
- h_next_test_step (&data);
-
- do
- {
- g_main_loop_run (loop);
- }
- while (data.expectation[data.test_step].type != DONE);
-
- fail_unless (idle_timer == 0);
-
-} END_TEST
-
-TCase *
-make_gibber_r_multicast_sender_tcase (void)
-{
- TCase *tc = tcase_create ("RMulticast Sender");
- tcase_set_timeout (tc, 20);
- tcase_add_loop_test (tc, test_sender, 0, NUMBER_OF_TESTS);
- tcase_add_loop_test (tc, test_holding, 0, NUMBER_OF_H_TESTS );
- return tc;
-}
diff --git a/tests/check-gibber-resolver.c b/tests/check-gibber-resolver.c
deleted file mode 100644
index ba6effa..0000000
--- a/tests/check-gibber-resolver.c
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * check-gibber-resolver.c - Test for gibber-resolver functions
- * Copyright (C) 2008 Collabora Ltd.
- * @author Sjoerd Simons <sjoerd.simons at collabora.co.uk>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "test-resolver.h"
-#include "check-gibber.h"
-
-#include <check.h>
-
-GMainLoop *mainloop = NULL;
-gboolean done = FALSE;
-
-static void
-resolver_srv_cb (GibberResolver *resolver, GList *srv_list, GError *error,
- gpointer user_data, GObject *weak_object)
-{
- GList *s;
- int last_prio = 0;
- int last_weight = 0;
-
- for (s = srv_list ; s != NULL; s = g_list_next (s))
- {
- GibberResolverSrvRecord *r = (GibberResolverSrvRecord *) s->data;
-
- fail_unless (last_prio <= r->priority);
-
- if (last_prio != r->priority)
- last_weight = 0;
-
- /* If our previous weight was non-zero, then this one has to be non-zero
- * too. The SRV RFC requires all entries with zero weight to be sorted
- * before all other entries with the same priority */
- fail_unless (last_weight == 0 || r->weight != 0);
-
- last_prio = r->priority;
- last_weight = r->weight;
- }
-
- done = TRUE;
-
- if (g_main_loop_is_running (mainloop))
- g_main_loop_quit (mainloop);
-}
-
-START_TEST (test_srv_resolving)
-{
- GibberResolver *resolver;
-
- done = FALSE;
- mainloop = g_main_loop_new (NULL, FALSE);
-
- resolver = g_object_new (TEST_TYPE_RESOLVER, NULL);
-
- gibber_resolver_srv (resolver, "test", "test",
- GIBBER_RESOLVER_SERVICE_TYPE_TCP,
- resolver_srv_cb, NULL, NULL, NULL);
-
- if (!done)
- g_main_loop_run (mainloop);
-
- g_main_loop_unref (mainloop);
-} END_TEST
-
-TCase *
-make_gibber_resolver_tcase (void)
-{
- TCase *tc = tcase_create ("Resolve");
- tcase_add_test (tc, test_srv_resolving);
- return tc;
-}
diff --git a/tests/check-gibber-sasl-auth.c b/tests/check-gibber-sasl-auth.c
deleted file mode 100644
index 4ce68ff..0000000
--- a/tests/check-gibber-sasl-auth.c
+++ /dev/null
@@ -1,213 +0,0 @@
-#include <stdio.h>
-
-#include "test-sasl-auth-server.h"
-#include "test-transport.h"
-#include <gibber/gibber-xmpp-connection.h>
-#include <gibber/gibber-sasl-auth.h>
-
-#include <check.h>
-#include "check-gibber.h"
-
-typedef struct {
- gchar *description;
- gchar *mech;
- gboolean allow_plain;
- GQuark domain;
- int code;
- ServerProblem problem;
-} test_t;
-
-GMainLoop *mainloop;
-GibberTransport *servertransport;
-GibberTransport *clienttransport;
-GibberXmppConnection *conn;
-GibberSaslAuth *sasl = NULL;
-
-const gchar *username = "test";
-const gchar *password = "test123";
-const gchar *servername = "testserver";
-
-gboolean authenticated = FALSE;
-gboolean run_done = FALSE;
-
-test_t *current_test = NULL;
-GError *error = NULL;
-
-static void
-got_error (GQuark domain, int code, const gchar *message)
-{
- g_set_error (&error, domain, code, "%s", message);
- run_done = TRUE;
- g_main_loop_quit (mainloop);
-}
-
-static gboolean
-send_hook (GibberTransport *transport, const guint8 *data,
- gsize length, GError **err, gpointer user_data)
-{
- GibberTransport *target =
- (servertransport == transport) ? clienttransport : servertransport;
-
- test_transport_write (TEST_TRANSPORT (target), data, length);
- return TRUE;
-}
-
-static gchar *
-return_str (GibberSaslAuth *auth, gpointer user_data)
-{
- return g_strdup (user_data);
-}
-
-static void
-auth_success (GibberSaslAuth *sasl_, gpointer user_data)
-{
- authenticated = TRUE;
- /* Reopen the connection */
- gibber_xmpp_connection_restart (conn);
- gibber_xmpp_connection_open (conn, servername, NULL, "1.0");
-}
-
-static void
-auth_failed (GibberSaslAuth *sasl_, GQuark domain,
- int code, gchar *message, gpointer user_data)
-{
- got_error (domain, code, message);
-}
-
-static void
-parse_error (GibberXmppConnection *connection, gpointer user_data)
-{
- fail ();
-}
-
-static void
-stream_opened (GibberXmppConnection *connection,
- gchar *from, gchar *to, gchar *version, gpointer user_data)
-{
- if (authenticated)
- gibber_xmpp_connection_close (conn);
-}
-
-static void
-stream_closed (GibberXmppConnection *connection, gpointer user_data)
-{
- run_done = TRUE;
- g_main_loop_quit (mainloop);
-}
-
-static void
-received_stanza (GibberXmppConnection *connection, GibberXmppStanza *stanza,
- gpointer user_data)
-{
- if (sasl == NULL)
- {
- GError *err = NULL;
- sasl = gibber_sasl_auth_new ();
-
- g_signal_connect (sasl, "username-requested",
- G_CALLBACK (return_str), (gpointer)username);
- g_signal_connect (sasl, "password-requested",
- G_CALLBACK (return_str), (gpointer)password);
- g_signal_connect (sasl, "authentication-succeeded",
- G_CALLBACK (auth_success), NULL);
- g_signal_connect (sasl, "authentication-failed",
- G_CALLBACK (auth_failed), NULL);
-
- if (!gibber_sasl_auth_authenticate (sasl, servername, connection, stanza,
- current_test->allow_plain, &err))
- {
- got_error (err->domain, err->code, err->message);
- g_error_free (err);
- }
- }
-}
-
-static void
-run_rest (test_t *test)
-{
- TestSaslAuthServer *server;
-
- servertransport = GIBBER_TRANSPORT(test_transport_new (send_hook, NULL));
-
- server = test_sasl_auth_server_new (servertransport, test->mech, username,
- password, test->problem);
-
- authenticated = FALSE;
- run_done = FALSE;
- current_test = test;
-
- clienttransport = GIBBER_TRANSPORT (test_transport_new (send_hook, NULL));
- conn = gibber_xmpp_connection_new (clienttransport);
-
- g_signal_connect (conn, "parse-error", G_CALLBACK (parse_error), NULL);
- g_signal_connect (conn, "stream-opened", G_CALLBACK (stream_opened), NULL);
- g_signal_connect (conn, "stream-closed", G_CALLBACK (stream_closed), NULL);
- g_signal_connect (conn, "received-stanza",
- G_CALLBACK (received_stanza), NULL);
- gibber_xmpp_connection_open (conn, servername, NULL, "1.0");
-
- if (!run_done)
- {
- g_main_loop_run (mainloop);
- }
-
- if (sasl != NULL)
- {
- g_object_unref (sasl);
- sasl = NULL;
- }
-
- g_object_unref (servertransport);
- g_object_unref (clienttransport);
- g_object_unref (conn);
-
- fail_if (test->domain == 0 && error != NULL);
- fail_if (test->domain != 0 && error == NULL);
-
- if (error != NULL)
- {
- fail_if (test->domain != error->domain);
- fail_if (test->code != error->code);
- }
-
- if (error != NULL)
- g_error_free (error);
-
- error = NULL;
-}
-
-#define SUCCESS(desc, mech, allow_plain) \
- { desc, mech, allow_plain, 0, 0, SERVER_PROBLEM_NO_PROBLEM }
-
-#define NUMBER_OF_TEST 6
-
-START_TEST (test_auth)
-{
- test_t tests[NUMBER_OF_TEST] = {
- SUCCESS("Normal authentication", NULL, TRUE),
- SUCCESS("Disallow PLAIN", "PLAIN", TRUE),
- SUCCESS("Plain method authentication", "PLAIN", TRUE),
- SUCCESS("Normal DIGEST-MD5 authentication", "DIGEST-MD5", TRUE),
-
- { "No supported mechanisms", "NONSENSE", TRUE,
- GIBBER_SASL_AUTH_ERROR, GIBBER_SASL_AUTH_ERROR_NO_SUPPORTED_MECHANISMS,
- SERVER_PROBLEM_NO_PROBLEM },
- { "No sasl support in server", NULL, TRUE,
- GIBBER_SASL_AUTH_ERROR, GIBBER_SASL_AUTH_ERROR_SASL_NOT_SUPPORTED,
- SERVER_PROBLEM_NO_SASL },
- };
-
- g_type_init ();
-
- mainloop = g_main_loop_new (NULL, FALSE);
-
- run_rest (&(tests[_i]));
-} END_TEST
-
-TCase *
-make_gibber_sasl_auth_tcase (void)
-{
- TCase *tc = tcase_create ("SASL Auth");
- tcase_add_loop_test (tc, test_auth, 0, NUMBER_OF_TEST);
- return tc;
-}
diff --git a/tests/check-gibber-xmpp-connection-listener.c b/tests/check-gibber-xmpp-connection-listener.c
deleted file mode 100644
index 8dd1931..0000000
--- a/tests/check-gibber-xmpp-connection-listener.c
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * check-gibber-xmpp-connection-listener.c - Test for
- * GibberXmppConnectionListener
- * Copyright (C) 2007 Collabora Ltd.
- * @author Guillaume Desmottes <guillaume.desmottes at collabora.co.uk>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-#include <gibber/gibber-linklocal-transport.h>
-#include <gibber/gibber-listener.h>
-#include <gibber/gibber-xmpp-connection.h>
-#include <gibber/gibber-xmpp-connection-listener.h>
-
-#include <check.h>
-#include "check-gibber.h"
-
-gboolean got_connection;
-
-static void
-new_connection_cb (GibberXmppConnectionListener *listener,
- GibberXmppConnection *connection,
- struct sockaddr *addr,
- guint size,
- gpointer user_data)
-{
- got_connection = TRUE;
-}
-
-static gboolean
-connect_to_port (int port)
-{
- GibberLLTransport *transport;
- struct sockaddr_in addr;
- gboolean result;
-
- transport = gibber_ll_transport_new ();
-
- memset (&addr, 0, sizeof (addr));
- addr.sin_family = AF_INET;
- addr.sin_port = htons (port);
- addr.sin_addr.s_addr = inet_addr ("127.0.0.1");
-
- result = gibber_ll_transport_open_sockaddr (transport,
- (struct sockaddr_storage *) &addr, NULL);
-
- g_object_unref (transport);
- return result;
-}
-
-START_TEST (test_listen)
-{
- GibberXmppConnectionListener *listener;
- int port;
- gboolean result;
-
- got_connection = FALSE;
-
- listener = gibber_xmpp_connection_listener_new ();
- fail_if (listener == NULL);
-
- g_signal_connect (listener, "new-connection", G_CALLBACK (new_connection_cb),
- NULL);
-
- for (port = 5298; port < 5400; port++)
- {
- GError *error = NULL;
- if (gibber_xmpp_connection_listener_listen (listener, port, &error))
- break;
-
- fail_if (!g_error_matches (error, GIBBER_LISTENER_ERROR,
- GIBBER_LISTENER_ERROR_ADDRESS_IN_USE));
- g_error_free (error);
- error = NULL;
- }
- fail_if (port >= 5400);
-
- result = connect_to_port (port);
- fail_if (result == FALSE);
-
- while (g_main_context_iteration (NULL, FALSE))
- ;
- fail_if (got_connection == FALSE);
-
- g_object_unref (listener);
-
- /* listener is destroyed, connection should be refused now */
- got_connection = FALSE;
- result = connect_to_port (port);
- fail_if (result == TRUE);
-} END_TEST
-
-TCase *
-make_gibber_xmpp_connection_listener_tcase (void)
-{
- TCase *tc = tcase_create ("GibberXmppConnectionListener");
- tcase_add_test (tc, test_listen);
- return tc;
-}
diff --git a/tests/check-gibber-xmpp-connection.c b/tests/check-gibber-xmpp-connection.c
deleted file mode 100644
index de9dd1d..0000000
--- a/tests/check-gibber-xmpp-connection.c
+++ /dev/null
@@ -1,126 +0,0 @@
-#include <stdio.h>
-#include <unistd.h>
-#include <glib.h>
-
-#include <gibber/gibber-xmpp-connection.h>
-#include <gibber/gibber-transport.h>
-#include "test-transport.h"
-#include "check-gibber.h"
-
-#include <check.h>
-
-struct _FileChunker {
- gchar *contents;
- gsize length;
- gsize size;
- gsize offset;
-};
-typedef struct _FileChunker FileChunker;
-
-static void
-file_chunker_destroy (FileChunker *fc) {
- g_free (fc->contents);
- g_free (fc);
-}
-
-
-static FileChunker *
-file_chunker_new (const gchar *filename, gsize chunk_size) {
- FileChunker *fc;
- fc = g_new0 (FileChunker, 1);
-
- fc->size = chunk_size;
- if (!g_file_get_contents (filename, &fc->contents, &fc->length, NULL)) {
- file_chunker_destroy (fc);
- return NULL;
- }
- return fc;
-}
-
-static gboolean
-file_chunker_get_chunk (FileChunker *fc,
- gchar **chunk,
- gsize *chunk_size) {
- if (fc->offset < fc->length) {
- *chunk_size = MIN (fc->length - fc->offset, fc->size);
- *chunk = fc->contents + fc->offset;
- fc->offset += *chunk_size;
- return TRUE;
- }
- return FALSE;
-}
-
-
-START_TEST (test_instantiation)
-{
- GibberXmppConnection *connection;
- TestTransport *transport;
-
- transport = test_transport_new (NULL, NULL);
- connection = gibber_xmpp_connection_new (GIBBER_TRANSPORT(transport));
-
- fail_if (connection == NULL);
-
- connection = gibber_xmpp_connection_new (NULL);
-
- fail_if (connection == NULL);
-}
-END_TEST
-
-static void
-parse_error_cb (GibberXmppConnection *connection, gpointer user_data)
-{
- gboolean *parse_error_found = user_data;
- *parse_error_found = TRUE;
-}
-
-START_TEST (test_simple_message)
-{
- GibberXmppConnection *connection;
- TestTransport *transport;
- gchar *chunk;
- gsize chunk_length;
- gboolean parse_error_found = FALSE;
- const gchar *srcdir;
- gchar *file;
- FileChunker *fc;
-
- srcdir = g_getenv ("srcdir");
- if (srcdir == NULL)
- {
- file = g_strdup ("inputs/simple-message.input");
- }
- else
- {
- file = g_strdup_printf ("%s/inputs/simple-message.input", srcdir);
- }
-
- fc = file_chunker_new (file, 10);
- fail_if (fc == NULL);
-
- transport = test_transport_new (NULL, NULL);
- connection = gibber_xmpp_connection_new (GIBBER_TRANSPORT(transport));
-
- g_signal_connect (connection, "parse-error",
- G_CALLBACK(parse_error_cb), &parse_error_found);
-
- while (!parse_error_found &&
- file_chunker_get_chunk (fc, &chunk, &chunk_length))
- {
- test_transport_write (transport, (guint8 *) chunk, chunk_length);
- }
-
- fail_if (parse_error_found);
-
- g_free (file);
- file_chunker_destroy (fc);
-} END_TEST
-
-TCase *
-make_gibber_xmpp_connection_tcase (void)
-{
- TCase *tc = tcase_create ("XMPP Connection");
- tcase_add_test (tc, test_instantiation);
- tcase_add_test (tc, test_simple_message);
- return tc;
-}
diff --git a/tests/check-gibber-xmpp-error.c b/tests/check-gibber-xmpp-error.c
deleted file mode 100644
index 3acc61c..0000000
--- a/tests/check-gibber-xmpp-error.c
+++ /dev/null
@@ -1,139 +0,0 @@
-/*
- * check-gibber-xmpp-error.c - Test for gibber-xmpp-error functions
- * Copyright (C) 2007 Collabora Ltd.
- * @author Guillaume Desmottes <guillaume.desmottes at collabora.co.uk>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <gibber/gibber-xmpp-error.h>
-
-#define DEBUG_FLAG DEBUG_XMPP
-#include <gibber/gibber-debug.h>
-
-#include <check.h>
-#include "check-gibber.h"
-
-static void
-test_xmpp_error_to_node_with_bad_request (void)
-{
- GibberXmppStanza *stanza;
- GibberXmppNode *node;
- const gchar *code;
- const gchar *type;
-
- stanza = gibber_xmpp_stanza_build (
- GIBBER_STANZA_TYPE_IQ, GIBBER_STANZA_SUB_TYPE_ERROR,
- "from", "to",
- GIBBER_STANZA_END);
- node = gibber_xmpp_error_to_node (XMPP_ERROR_BAD_REQUEST, stanza->node,
- NULL);
-
- fail_if (node == NULL);
- fail_if (strcmp (node->name, "error") != 0);
-
- code = gibber_xmpp_node_get_attribute (node, "code");
- fail_if (code == NULL || strcmp (code, "400") != 0);
-
- type = gibber_xmpp_node_get_attribute (node, "type");
- fail_if (type == NULL || strcmp (type, "modify") != 0);
-
- fail_if (gibber_xmpp_node_get_child_ns (node, "bad-request",
- "urn:ietf:params:xml:ns:xmpp-stanzas") == NULL);
-
- g_object_unref (stanza);
-}
-
-static void
-test_xmpp_error_to_node_with_si_bad_profile (void)
-{
- GibberXmppStanza *stanza;
- GibberXmppNode *node;
- const gchar *code;
- const gchar *type;
-
- stanza = gibber_xmpp_stanza_build (
- GIBBER_STANZA_TYPE_IQ, GIBBER_STANZA_SUB_TYPE_ERROR,
- "from", "to",
- GIBBER_STANZA_END);
- node = gibber_xmpp_error_to_node (XMPP_ERROR_SI_BAD_PROFILE, stanza->node,
- NULL);
-
- fail_if (node == NULL);
- fail_if (strcmp (node->name, "error") != 0);
-
- code = gibber_xmpp_node_get_attribute (node, "code");
- fail_if (code == NULL || strcmp (code, "400") != 0);
-
- type = gibber_xmpp_node_get_attribute (node, "type");
- fail_if (type == NULL || strcmp (type, "modify") != 0);
-
- fail_if (gibber_xmpp_node_get_child_ns (node, "bad-request",
- "urn:ietf:params:xml:ns:xmpp-stanzas") == NULL);
-
- fail_if (gibber_xmpp_node_get_child_ns (node, "bad-profile",
- "http://jabber.org/protocol/si") == NULL);
-
- g_object_unref (stanza);
-}
-
-START_TEST (test_xmpp_error_to_node)
-{
- test_xmpp_error_to_node_with_bad_request ();
- test_xmpp_error_to_node_with_si_bad_profile ();
-} END_TEST
-
-START_TEST (test_message_get_xmpp_error)
-{
- GibberXmppError xmpp_error;
-
- for (xmpp_error = 1; xmpp_error < NUM_XMPP_ERRORS; xmpp_error++)
- {
- GibberXmppStanza *stanza;
- GError *error = NULL;
-
- stanza = gibber_xmpp_stanza_build (
- GIBBER_STANZA_TYPE_IQ, GIBBER_STANZA_SUB_TYPE_ERROR,
- "from", "to",
- GIBBER_STANZA_END);
- gibber_xmpp_error_to_node (xmpp_error, stanza->node, NULL);
-
- error = gibber_message_get_xmpp_error (stanza);
- fail_if (error == NULL);
-
- fail_if (error->domain != GIBBER_XMPP_ERROR);
- fail_if (error->code != (gint) xmpp_error);
- fail_if (strcmp (error->message, gibber_xmpp_error_description (
- xmpp_error)) != 0);
-
- g_object_unref (stanza);
- g_error_free (error);
- }
-
-} END_TEST
-
-TCase *
-make_gibber_xmpp_error_tcase (void)
-{
- TCase *tc = tcase_create ("XMPP Error");
- tcase_add_test (tc, test_xmpp_error_to_node);
- tcase_add_test (tc, test_message_get_xmpp_error);
- return tc;
-}
diff --git a/tests/check-gibber-xmpp-node.c b/tests/check-gibber-xmpp-node.c
deleted file mode 100644
index 3f5ea32..0000000
--- a/tests/check-gibber-xmpp-node.c
+++ /dev/null
@@ -1,167 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <gibber/gibber-xmpp-node.h>
-
-#include <check.h>
-#include "check-helpers.h"
-#include "check-gibber.h"
-
-START_TEST (test_instantiation)
-{
- GibberXmppNode *node;
- node = gibber_xmpp_node_new ("test");
- fail_unless (node != NULL);
-
- gibber_xmpp_node_free (node);
-
- node = gibber_xmpp_node_new (NULL);
- fail_unless (node != NULL);
-
- gibber_xmpp_node_free (node);
-}
-END_TEST
-
-START_TEST (test_language)
-{
- GibberXmppNode *node;
- const gchar *lang;
-
- /* Unit test are not examples of how to use an API! Don't rely on the
- * following in your applications! (or better yet, don't give invalid input)
- * */
- fail_unless_critical (lang = gibber_xmpp_node_get_language (NULL));
- fail_unless (lang == NULL);
-
- node = gibber_xmpp_node_new ("test");
- lang = gibber_xmpp_node_get_language (node);
- fail_unless (lang == NULL);
-
- gibber_xmpp_node_set_language (node, "en");
- lang = gibber_xmpp_node_get_language (node);
- fail_unless (strcmp (lang, "en") == 0);
-
- gibber_xmpp_node_set_language (node, NULL);
- lang = gibber_xmpp_node_get_language (node);
- fail_unless (lang == NULL);
-
- gibber_xmpp_node_set_language_n (node, "en-US", 2);
- lang = gibber_xmpp_node_get_language (node);
- fail_unless (strcmp (lang, "en") == 0);
-
- gibber_xmpp_node_set_language_n (node, NULL, 2);
- lang = gibber_xmpp_node_get_language (node);
- fail_unless (lang == NULL);
-
- gibber_xmpp_node_free (node);
-}
-END_TEST
-
-START_TEST (test_namespace)
-{
- GibberXmppNode *node;
- const gchar *ns;
-
- node = gibber_xmpp_node_new ("test");
-
- ns = gibber_xmpp_node_get_ns (node);
- fail_unless (ns == NULL);
-
- gibber_xmpp_node_set_ns (node, "foo");
- ns = gibber_xmpp_node_get_ns (node);
- fail_unless (strcmp (ns, "foo") == 0);
-
- gibber_xmpp_node_set_ns (node, NULL);
- ns = gibber_xmpp_node_get_ns (node);
- fail_unless (ns == NULL);
-
- gibber_xmpp_node_free (node);
-}
-END_TEST
-
-
-START_TEST (test_attribute)
-{
- GibberXmppNode *node;
- const gchar *attribute;
-
- node = gibber_xmpp_node_new ("test");
-
- attribute = gibber_xmpp_node_get_attribute (node, "foo");
- fail_unless (attribute == NULL);
-
- attribute = gibber_xmpp_node_get_attribute (node, NULL);
- fail_unless (attribute == NULL);
-
- attribute = gibber_xmpp_node_get_attribute_ns (node, "foo", "bar");
- fail_unless (attribute == NULL);
-
- gibber_xmpp_node_set_attribute (node, "foo", "baz");
-
- attribute = gibber_xmpp_node_get_attribute (node, "foo");
- fail_unless (strcmp ( attribute, "baz") == 0);
-
- attribute = gibber_xmpp_node_get_attribute_ns (node, "foo", "bar");
- fail_unless (attribute == NULL);
-
- gibber_xmpp_node_set_attribute_ns (node, "foobar", "barbaz", "bar");
-
- attribute = gibber_xmpp_node_get_attribute (node, "foobar");
- fail_unless (strcmp (attribute, "barbaz") == 0);
-
- attribute = gibber_xmpp_node_get_attribute_ns (node, "foobar", "bar");
- fail_unless (strcmp (attribute, "barbaz") == 0);
-
- attribute = gibber_xmpp_node_get_attribute_ns (node, "barfoo", "bar");
- fail_unless (attribute == NULL);
-
- gibber_xmpp_node_free (node);
-}
-END_TEST
-
-START_TEST (test_child)
-{
- GibberXmppNode *node, *child;
-
- node = gibber_xmpp_node_new ("test");
-
- child = gibber_xmpp_node_get_child (node, "foo");
- fail_unless (child == NULL);
-
- gibber_xmpp_node_add_child (node, "foo");
- child = gibber_xmpp_node_get_child (node, "foo");
- fail_if (child == NULL);
- fail_unless (strcmp (child->name, "foo") == 0);
-
- child = gibber_xmpp_node_get_child_ns (node, "foo", "bar");
- fail_unless (child == NULL);
-
- gibber_xmpp_node_add_child_ns (node, "foobar", "bar");
- child = gibber_xmpp_node_get_child_ns (node, "foobar", "foo");
- fail_unless (child == NULL);
- child = gibber_xmpp_node_get_child_ns (node, "foobar", "bar");
- fail_if (child == NULL);
- fail_unless (strcmp (child->name, "foobar") == 0);
-
- gibber_xmpp_node_add_child_with_content (node, "foo2", "blah");
- child = gibber_xmpp_node_get_child (node, "foo2");
- fail_if (child->content == NULL);
- fail_unless (strcmp (child->content, "blah") == 0);
-
- gibber_xmpp_node_free (node);
-}
-END_TEST
-
-
-TCase *
-make_gibber_xmpp_node_tcase (void)
-{
- TCase *tc = tcase_create ("XMPP Node");
- tcase_add_test (tc, test_instantiation);
- tcase_add_test (tc, test_language);
- tcase_add_test (tc, test_namespace);
- tcase_add_test (tc, test_attribute);
- tcase_add_test (tc, test_child);
- return tc;
-}
diff --git a/tests/check-gibber-xmpp-reader.c b/tests/check-gibber-xmpp-reader.c
deleted file mode 100644
index d6bb8b0..0000000
--- a/tests/check-gibber-xmpp-reader.c
+++ /dev/null
@@ -1,127 +0,0 @@
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#include <gibber/gibber-xmpp-reader.h>
-#include <gibber/gibber-xmpp-stanza.h>
-
-#include <check.h>
-
-#include "check-gibber.h"
-
-typedef struct _ReceivedStanzaEvent ReceivedStanzaEvent;
-
-struct _ReceivedStanzaEvent {
- GibberXmppReader *reader;
- GibberXmppStanza *stanza;
-};
-
-static void received_stanza_cb (GibberXmppReader *reader,
- GibberXmppStanza *stanza, gpointer user_data)
-{
- GQueue *events_queue = (GQueue *) user_data;
- ReceivedStanzaEvent *event;
-
- fail_if (reader == NULL);
- fail_if (stanza == NULL);
- fail_if (events_queue == NULL);
-
- g_object_ref (stanza);
-
- event = g_new (ReceivedStanzaEvent, 1);
- event->reader = reader;
- event->stanza = stanza;
-
- g_queue_push_tail (events_queue, event);
-}
-
-
-START_TEST (test_instantiation)
-{
- GibberXmppReader *reader;
- reader = gibber_xmpp_reader_new_no_stream ();
- fail_if (reader == NULL);
- g_object_unref (reader);
-}
-END_TEST
-
-START_TEST (test_simple_message)
-{
- GibberXmppReader *reader;
- GibberXmppNode *node;
- gchar *data;
- gsize length;
- gboolean valid;
- GQueue *received_stanzas;
- ReceivedStanzaEvent *event;
- const gchar *srcdir;
- gchar *file;
-
- received_stanzas = g_queue_new ();
-
- reader = gibber_xmpp_reader_new ();
- g_signal_connect (reader, "received-stanza",
- G_CALLBACK (received_stanza_cb), received_stanzas);
-
- srcdir = g_getenv ("srcdir");
- if (srcdir == NULL)
- {
- file = g_strdup ("inputs/simple-message.input");
- }
- else
- {
- file = g_strdup_printf ("%s/inputs/simple-message.input", srcdir);
- }
-
- fail_unless (g_file_get_contents (file, &data, &length, NULL));
- g_free (file);
-
- valid = gibber_xmpp_reader_push (reader, (guint8 *) data, length, NULL);
- fail_unless (valid);
-
- fail_unless (g_queue_get_length (received_stanzas) == 2);
-
- event = g_queue_pop_head (received_stanzas);
-
- fail_unless (event->reader == reader);
-
- node = event->stanza->node;
- fail_if (node == NULL);
- fail_unless (strcmp (node->name, "message") == 0);
- fail_unless (strcmp (gibber_xmpp_node_get_language (node), "en") == 0);
- fail_unless (strcmp (gibber_xmpp_node_get_attribute (node, "to"),
- "juliet at example.com") == 0);
- fail_unless (strcmp (gibber_xmpp_node_get_attribute (node, "id"),
- "0") == 0);
-
- g_object_unref (event->stanza);
- g_free (event);
-
- event = g_queue_pop_head (received_stanzas);
-
- fail_unless (event->reader == reader);
-
- node = event->stanza->node;
- fail_unless (strcmp (node->name, "message") == 0);
- fail_unless (strcmp (gibber_xmpp_node_get_language (node), "en") == 0);
- fail_unless (strcmp (gibber_xmpp_node_get_attribute (node, "to"),
- "juliet at example.com") == 0);
- fail_unless (strcmp (gibber_xmpp_node_get_attribute (node, "id"),
- "1") == 0);
-
- g_free (data);
- g_queue_free (received_stanzas);
- g_object_unref (event->stanza);
- g_free (event);
- g_object_unref (reader);
-}
-END_TEST
-
-TCase *
-make_gibber_xmpp_reader_tcase (void)
-{
- TCase *tc = tcase_create ("XMPP Reader");
- tcase_add_test (tc, test_instantiation);
- tcase_add_test (tc, test_simple_message);
- return tc;
-}
diff --git a/tests/check-gibber-xmpp-stanza.c b/tests/check-gibber-xmpp-stanza.c
deleted file mode 100644
index ab0e62d..0000000
--- a/tests/check-gibber-xmpp-stanza.c
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
- * check-gibber-xmpp-stanza.c - Test for gibber-xmpp-stanza functions
- * Copyright (C) 2007 Collabora Ltd.
- * @author Guillaume Desmottes <guillaume.desmottes at collabora.co.uk>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <gibber/gibber-xmpp-stanza.h>
-
-#define DEBUG_FLAG DEBUG_XMPP
-#include <gibber/gibber-debug.h>
-
-#include <check.h>
-#include "check-gibber.h"
-
-START_TEST (test_build_with_html_message)
-{
- GibberXmppStanza *stanza;
- const gchar *body = "Telepathy rocks!",
- *xhtml_ns = "http://www.w3.org/1999/xhtml";
- GibberXmppNode *node;
- const gchar *value;
-
- g_type_init ();
-#ifdef ENABLE_DEBUG
- gibber_debug_set_flags_from_env ();
-#endif
-
- stanza = gibber_xmpp_stanza_build (
- GIBBER_STANZA_TYPE_MESSAGE, GIBBER_STANZA_SUB_TYPE_NONE,
- "alice at collabora.co.uk", "bob at collabora.co.uk",
- GIBBER_NODE, "html",
- GIBBER_NODE_XMLNS, xhtml_ns,
- GIBBER_NODE, "body",
- GIBBER_NODE_ATTRIBUTE, "textcolor", "red",
- GIBBER_NODE_TEXT, body,
- GIBBER_NODE_END,
- GIBBER_NODE_END,
- GIBBER_STANZA_END);
-
- DEBUG_STANZA (stanza, "check");
-
- fail_if (stanza == NULL);
- /* <message> */
- node = stanza->node;
- fail_if (node == NULL);
- fail_unless (strcmp (node->name, "message") == 0);
- value = gibber_xmpp_node_get_attribute (node, "type");
- fail_unless (value == NULL);
- value = gibber_xmpp_node_get_attribute (node, "from");
- fail_unless (strcmp (value, "alice at collabora.co.uk") == 0);
- value = gibber_xmpp_node_get_attribute (node, "to");
- fail_unless (strcmp (value, "bob at collabora.co.uk") == 0);
-
- /* <html> */
- node = gibber_xmpp_node_get_child_ns (node, "html", xhtml_ns);
- fail_if (node == NULL);
-
- /* <body> */
- node = gibber_xmpp_node_get_child (node, "body");
- fail_if (node == NULL);
- value = gibber_xmpp_node_get_attribute (node, "textcolor");
- fail_unless (strcmp (value, "red") == 0);
- fail_unless (strcmp (node->content, body) == 0);
-
- g_object_unref (stanza);
-} END_TEST
-
-START_TEST (test_get_type_info_with_simple_message)
-{
- GibberXmppStanza *stanza;
- GibberStanzaType type;
- GibberStanzaSubType sub_type;
-
- stanza = gibber_xmpp_stanza_build (
- GIBBER_STANZA_TYPE_MESSAGE, GIBBER_STANZA_SUB_TYPE_NONE,
- "alice at collabora.co.uk", "bob at collabora.co.uk",
- GIBBER_STANZA_END);
- fail_if (stanza == NULL);
-
- gibber_xmpp_stanza_get_type_info (stanza, &type, &sub_type);
- fail_if (type != GIBBER_STANZA_TYPE_MESSAGE);
- fail_if (sub_type != GIBBER_STANZA_SUB_TYPE_NONE);
-
- g_object_unref (stanza);
-} END_TEST
-
-START_TEST (test_get_type_info_with_iq_set)
-{
- GibberXmppStanza *stanza;
- GibberStanzaType type;
- GibberStanzaSubType sub_type;
-
- stanza = gibber_xmpp_stanza_build (
- GIBBER_STANZA_TYPE_IQ, GIBBER_STANZA_SUB_TYPE_SET,
- "alice at collabora.co.uk", "bob at collabora.co.uk",
- GIBBER_STANZA_END);
- fail_if (stanza == NULL);
-
- gibber_xmpp_stanza_get_type_info (stanza, &type, &sub_type);
- fail_if (type != GIBBER_STANZA_TYPE_IQ);
- fail_if (sub_type != GIBBER_STANZA_SUB_TYPE_SET);
-
- g_object_unref (stanza);
-} END_TEST
-
-START_TEST (test_get_type_info_with_unknown_type)
-{
- GibberXmppStanza *stanza;
- GibberStanzaType type;
-
- stanza = gibber_xmpp_stanza_new ("goat");
- fail_if (stanza == NULL);
-
- gibber_xmpp_stanza_get_type_info (stanza, &type, NULL);
- fail_if (type != GIBBER_STANZA_TYPE_UNKNOWN);
-
- g_object_unref (stanza);
-} END_TEST
-
-START_TEST (test_get_type_info_with_unknown_sub_type)
-{
- GibberXmppStanza *stanza;
- GibberStanzaSubType sub_type;
-
- stanza = gibber_xmpp_stanza_new ("iq");
- fail_if (stanza == NULL);
- gibber_xmpp_node_set_attribute (stanza->node, "type", "goat");
-
- gibber_xmpp_stanza_get_type_info (stanza, NULL, &sub_type);
- fail_if (sub_type != GIBBER_STANZA_SUB_TYPE_UNKNOWN);
-
- g_object_unref (stanza);
-} END_TEST
-
-
-TCase *
-make_gibber_xmpp_stanza_tcase (void)
-{
- TCase *tc = tcase_create ("XMPP Stanza");
- tcase_add_test (tc, test_build_with_html_message);
- tcase_add_test (tc, test_get_type_info_with_simple_message);
- tcase_add_test (tc, test_get_type_info_with_iq_set);
- tcase_add_test (tc, test_get_type_info_with_unknown_type);
- tcase_add_test (tc, test_get_type_info_with_unknown_sub_type);
- return tc;
-}
diff --git a/tests/check-gibber.h b/tests/check-gibber.h
deleted file mode 100644
index edd747f..0000000
--- a/tests/check-gibber.h
+++ /dev/null
@@ -1,20 +0,0 @@
-#ifndef __CHECK_GIBBER_H__
-#define __CHECK_GIBBER_H__
-
-#include <check.h>
-
-TCase *make_gibber_xmpp_node_tcase (void);
-TCase *make_gibber_xmpp_reader_tcase (void);
-TCase *make_gibber_xmpp_connection_tcase (void);
-TCase *make_gibber_sasl_auth_tcase (void);
-TCase *make_gibber_resolver_tcase (void);
-TCase *make_gibber_r_multicast_packet_tcase (void);
-TCase *make_gibber_r_multicast_causal_transport_tcase (void);
-TCase *make_gibber_r_multicast_sender_tcase (void);
-TCase *make_gibber_xmpp_stanza_tcase (void);
-TCase *make_gibber_iq_helper_tcase (void);
-TCase *make_gibber_listener_tcase (void);
-TCase *make_gibber_xmpp_connection_listener_tcase (void);
-TCase *make_gibber_xmpp_error_tcase (void);
-
-#endif /* #ifndef __CHECK_GIBBER_H__ */
diff --git a/tests/check-main.c b/tests/check-main.c
index 7df4f38..7d1a85f 100644
--- a/tests/check-main.c
+++ b/tests/check-main.c
@@ -5,37 +5,12 @@
#include <check.h>
-#include "check-gibber.h"
#include "check-salut.h"
#include "check-helpers.h"
#include "config.h"
static Suite *
-make_gibber_suite (void)
-{
- Suite *s = suite_create ("Gibber");
-
- suite_add_tcase (s, make_gibber_xmpp_node_tcase ());
- suite_add_tcase (s, make_gibber_xmpp_reader_tcase ());
- suite_add_tcase (s, make_gibber_xmpp_connection_tcase ());
-#ifdef HAVE_LIBSASL2
- suite_add_tcase (s, make_gibber_sasl_auth_tcase ());
-#endif
- suite_add_tcase (s, make_gibber_resolver_tcase ());
- suite_add_tcase (s, make_gibber_r_multicast_packet_tcase ());
- suite_add_tcase (s, make_gibber_r_multicast_sender_tcase ());
- suite_add_tcase (s, make_gibber_r_multicast_causal_transport_tcase ());
- suite_add_tcase (s, make_gibber_xmpp_stanza_tcase ());
- suite_add_tcase (s, make_gibber_iq_helper_tcase ());
- suite_add_tcase (s, make_gibber_listener_tcase ());
- suite_add_tcase (s, make_gibber_xmpp_connection_listener_tcase ());
- suite_add_tcase (s, make_gibber_xmpp_error_tcase ());
-
- return s;
-}
-
-static Suite *
make_salut_suite (void)
{
Suite *s = suite_create ("Salut");
@@ -55,12 +30,6 @@ main (void)
check_helpers_init ();
g_type_init ();
- s = make_gibber_suite ();
- sr = srunner_create (s);
- srunner_run_all (sr, CK_NORMAL);
- number_failed += srunner_ntests_failed (sr);
- srunner_free (sr);
-
s = make_salut_suite ();
sr = srunner_create (s);
srunner_run_all (sr, CK_NORMAL);
diff --git a/tests/inputs/Makefile.am b/tests/inputs/Makefile.am
deleted file mode 100644
index 0b8b19f..0000000
--- a/tests/inputs/Makefile.am
+++ /dev/null
@@ -1,5 +0,0 @@
-EXTRA_DIST = \
- groupchat-invite.input \
- simple-message-attrnamespace.input \
- simple-message.input \
- strange-streamopening.input
diff --git a/tests/inputs/groupchat-invite.input b/tests/inputs/groupchat-invite.input
deleted file mode 100644
index 3c7954f..0000000
--- a/tests/inputs/groupchat-invite.input
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<stream:stream xmlns='jabber:client'
- xmlns:stream='http://etherx.jabber.org/streams'>
-
-<message
- from='crone1 at shakespeare.lit/desktop'
- to='darkcave at macbeth.shakespeare.lit' id="0">
- <x xmlns='http://jabber.org/protocol/muc#user'>
- <invite to='hecate at shakespeare.lit'>
- <reason>
- Hey Hecate, this is the place for all good witches!
- </reason>
- </invite>
- </x>
-</message>
-
-<message
- from='darkcave at macbeth.shakespeare.lit'
- to='hecate at shakespeare.lit' id="1">
- <body>You have been invited to darkcave at macbeth by crone1 at shakespeare.lit.</body>
- <x xmlns='http://jabber.org/protocol/muc#user'>
- <invite from='crone1 at shakespeare.lit'>
- <reason>
- Hey Hecate, this is the place for all good witches!
- </reason>
- </invite>
- <password>cauldronburn</password>
- </x>
-</message>
-
-
-</stream:stream>
diff --git a/tests/inputs/simple-message-attrnamespace.input b/tests/inputs/simple-message-attrnamespace.input
deleted file mode 100644
index b85d92f..0000000
--- a/tests/inputs/simple-message-attrnamespace.input
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<stream:stream xmlns='jabber:client'
- xmlns:stream='http://etherx.jabber.org/streams'>
-
- <message to='juliet at example.com' from='romeo at example.net' xml:lang='en'
- id="0">
- <body>Art thou not Romeo, and a Montague?</body>
- </message>
-
- <message from='romeo at example.net'
- to='juliet at example.com'
- stream:blaat='blaat'
- xml:lang='en' id="1">
- <body>Neither, fair saint, if either thee dislike.</body>
- </message>
-
-</stream:stream>
diff --git a/tests/inputs/simple-message.input b/tests/inputs/simple-message.input
deleted file mode 100644
index a3989ae..0000000
--- a/tests/inputs/simple-message.input
+++ /dev/null
@@ -1,16 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<stream:stream xmlns='jabber:client'
- xmlns:stream='http://etherx.jabber.org/streams'>
-
- <message to='juliet at example.com' from='romeo at example.net' xml:lang='en'
- id="0">
- <body>Art thou not Romeo, and a Montague?</body>
- </message>
-
- <message from='romeo at example.net'
- to='juliet at example.com'
- xml:lang='en' id="1">
- <body>Neither, fair saint, if either thee dislike.</body>
- </message>
-
-</stream:stream>
diff --git a/tests/inputs/strange-streamopening.input b/tests/inputs/strange-streamopening.input
deleted file mode 100644
index 4685541..0000000
--- a/tests/inputs/strange-streamopening.input
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version='1.0' encoding='utf-8'?>
-<stream:stream xmlns='jabber:client'
- xmlns:stream='http://etherx.jabber.org/streams'
- from='rome"&@example.net'
- to='ex"&ample.net'>
-
- <aap bla="&" id="0"/>
-
-</stream:stream>
diff --git a/tests/inputs/tls-stream-start.input b/tests/inputs/tls-stream-start.input
deleted file mode 100644
index d30bcf8..0000000
--- a/tests/inputs/tls-stream-start.input
+++ /dev/null
@@ -1,18 +0,0 @@
-<stream:stream
- xmlns='jabber:client'
- xmlns:stream='http://etherx.jabber.org/streams'
- to='example.com'
- version='1.0'>
-
- <stream:features id="0">
- <starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'>
- <required/>
- </starttls>
- <mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>
- <mechanism>DIGEST-MD5</mechanism>
- <mechanism>PLAIN</mechanism>
- </mechanisms>
- </stream:features>
-
- <starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls' id="1"/>
-</stream:stream>
diff --git a/tests/run-xmpp-connection-test.sh b/tests/run-xmpp-connection-test.sh
deleted file mode 100755
index e2337ab..0000000
--- a/tests/run-xmpp-connection-test.sh
+++ /dev/null
@@ -1,29 +0,0 @@
-#!/bin/sh
-
-mkdir -p outputs
-
-RET=0
-
-
-srcdir=${srdir:=$(dirname $0)}
-
-for x in ${srcdir}/inputs/*.input ; do
- FILE=$(basename ${x%.input})
- XMLOUT="outputs/${FILE}.output"
- PARSEOUT="outputs/${FILE}.parse"
- ./test-xmpp-connection $x ${PARSEOUT} ${XMLOUT}
- if [ $? -ne 0 ] ; then
- echo "FAILED: $x - Test program had non-zero exit status" >&2
- RET=1
- continue
- fi
- xmldiff $x $XMLOUT
- if [ $? -ne 0 ] ; then
- echo "FAILED: $x - XML output doesn't match the input" >&2
- RET=1
- continue
- fi
- echo "SUCCESS: $x" >&2
-done
-
-exit ${RET}
diff --git a/tests/test-r-multicast-transport-io.c b/tests/test-r-multicast-transport-io.c
deleted file mode 100644
index 62a4e96..0000000
--- a/tests/test-r-multicast-transport-io.c
+++ /dev/null
@@ -1,226 +0,0 @@
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <glib.h>
-
-#include <gibber/gibber-r-multicast-transport.h>
-#include <gibber/gibber-debug.h>
-#include "test-transport.h"
-
-GMainLoop *loop;
-
-TestTransport *t;
-GibberRMulticastTransport *rm;
-GibberRMulticastCausalTransport *rmc;
-gulong rmc_connected_handler = 0;
-
-static void
-received_data (GibberTransport *transport, GibberBuffer *buffer,
- gpointer user_data)
-{
- GibberRMulticastBuffer *rmbuffer = (GibberRMulticastBuffer *) buffer;
- gchar *b64;
-
- b64 = g_base64_encode ((guchar *) buffer->data, buffer->length);
- printf ("OUTPUT:%s:%s\n", rmbuffer->sender, b64);
- fflush (stdout);
- g_free (b64);
-}
-
-static gboolean
-send_hook (GibberTransport *transport, const guint8 *data, gsize length,
- GError **error, gpointer user_data)
-{
- gchar *b64;
-
- b64 = g_base64_encode ((guchar *) data, length);
- printf ("SEND:%s\n", b64);
- fflush (stdout);
- g_free (b64);
-
- return TRUE;
-}
-
-static void
-fail_node (gchar *name)
-{
- GibberRMulticastSender *sender;
-
- name = g_strstrip (name);
-
- sender = gibber_r_multicast_causal_transport_get_sender_by_name (rmc, name);
- g_assert (sender != NULL);
-
- _gibber_r_multicast_TEST_sender_fail (sender);
-}
-
-static gboolean
-got_input (GIOChannel *source, GIOCondition condition, gpointer user_data)
-{
- GIOStatus s;
- gchar *buffer;
- gsize len;
- gchar *p;
- gboolean packet = FALSE;
- guchar *b64;
- gsize size;
-
- s = g_io_channel_read_line (source, &buffer, &len, NULL, NULL);
- g_assert (s == G_IO_STATUS_NORMAL);
-
- if (g_str_has_prefix (buffer, "INPUT:"))
- {
- packet = FALSE;
- p = buffer + strlen ("INPUT:");
- }
- else if (g_str_has_prefix (buffer, "RECV:"))
- {
- packet = TRUE;
- p = buffer + strlen ("RECV:");
- }
- else if (strcmp (buffer, "DISCONNECT\n") == 0)
- {
- gibber_transport_disconnect (GIBBER_TRANSPORT(rm));
- goto out;
- }
- else if (g_str_has_prefix (buffer, "FAIL:"))
- {
- /* this will modify our buffer */
- fail_node (buffer + strlen ("FAIL:"));
- goto out;
- }
- else
- {
- g_assert_not_reached ();
- }
-
- b64 = g_base64_decode (p, &size);
-
- if (packet)
- {
- test_transport_write (t, b64, size);
- }
- else
- {
- g_assert (gibber_transport_send (GIBBER_TRANSPORT (rm),
- b64, size, NULL));
- }
-
- g_free (b64);
-out:
- g_free (buffer);
-
- return TRUE;
-}
-
-static gboolean
-got_error (GIOChannel *source, GIOCondition condition, gpointer user_data)
-{
- g_main_loop_quit (loop);
- fprintf (stderr, "error");
- fflush (stderr);
- return TRUE;
-}
-
-static void
-new_senders_cb (GibberRMulticastTransport *transport,
- GArray *names, gpointer user_data)
-{
- guint i;
- GString *str = g_string_new ("NEWNODES:");
-
- for (i = 0; i < names->len; i++)
- {
- g_string_append_printf (str, "%s ", g_array_index (names, gchar *, i));
- }
- printf ("%s\n", str->str);
- g_string_free (str, TRUE);
- fflush (stdout);
-}
-
-static void
-lost_senders_cb (GibberRMulticastTransport *transport,
- GArray *names, gpointer user_data)
-{
- guint i;
- GString *str = g_string_new ("LOSTNODES:");
-
- for (i = 0; i < names->len; i++)
- {
- g_string_append_printf (str, "%s ", g_array_index (names, gchar *, i));
- }
- printf ("%s\n", str->str);
- g_string_free (str, TRUE);
- fflush (stdout);
-}
-
-static void
-rm_connected (GibberRMulticastTransport *transport, gpointer user_data)
-{
- printf ("CONNECTED:\n");
- fflush (stdout);
-}
-
-static void
-rm_disconnected (GibberRMulticastTransport *transport, gpointer user_data)
-{
- printf ("DISCONNECTED:\n");
- fflush (stdout);
- g_main_loop_quit (loop);
-}
-
-static void
-rmc_connected (GibberRMulticastTransport *transport, gpointer user_data)
-{
- g_assert (gibber_r_multicast_transport_connect (rm, NULL));
- g_signal_handler_disconnect (transport, rmc_connected_handler);
-}
-
-int
-main (int argc, char **argv)
-{
- GIOChannel *io;
-
- g_assert (argc == 2);
-
- g_type_init ();
-
- printf ("Starting process %d for %s\n", getpid (), argv[1]);
-
- loop = g_main_loop_new (NULL, FALSE);
-
- t = test_transport_new (send_hook, argv[1]);
- GIBBER_TRANSPORT (t)->max_packet_size = 1500;
- test_transport_set_echoing (t, TRUE);
-
- rmc = gibber_r_multicast_causal_transport_new (GIBBER_TRANSPORT (t),
- argv[1]);
- g_object_unref (t);
-
- rm = gibber_r_multicast_transport_new (rmc);
- gibber_transport_set_handler (GIBBER_TRANSPORT (rm), received_data, argv[1]);
- g_object_unref (rmc);
-
- g_signal_connect (rm, "new-senders", G_CALLBACK (new_senders_cb), NULL);
-
- g_signal_connect (rm, "lost-senders", G_CALLBACK (lost_senders_cb), NULL);
-
- rmc_connected_handler = g_signal_connect (rmc, "connected",
- G_CALLBACK (rmc_connected), NULL);
-
- g_signal_connect (rm, "connected", G_CALLBACK (rm_connected), NULL);
-
- g_signal_connect (rm, "disconnected", G_CALLBACK (rm_disconnected), NULL);
-
- /* test transport starts out connected */
- g_assert (gibber_r_multicast_causal_transport_connect (rmc, FALSE, NULL));
-
- io = g_io_channel_unix_new (STDIN_FILENO);
- g_io_add_watch (io, G_IO_IN, got_input, NULL);
- g_io_add_watch (io, G_IO_HUP|G_IO_ERR, got_error, NULL);
-
- g_main_loop_run (loop);
-
- return 0;
-}
diff --git a/tests/test-resolver.c b/tests/test-resolver.c
deleted file mode 100644
index bb6ab8d..0000000
--- a/tests/test-resolver.c
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * test-resolver.c - Source for TestResolver
- * Copyright (C) 2008 Collabora Ltd.
- * @author Sjoerd Simons <sjoerd.simons at collabora.co.uk>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "test-resolver.h"
-
-G_DEFINE_TYPE(TestResolver, test_resolver, GIBBER_TYPE_RESOLVER)
-
-/* private structure */
-typedef struct _TestResolverPrivate TestResolverPrivate;
-
-struct _TestResolverPrivate
-{
- gboolean dispose_has_run;
-};
-
-#define TEST_RESOLVER_GET_PRIVATE(o) \
- (G_TYPE_INSTANCE_GET_PRIVATE ((o), TEST_TYPE_RESOLVER, TestResolverPrivate))
-
-static void
-test_resolver_init (TestResolver *obj)
-{
-}
-
-static void test_resolver_dispose (GObject *object);
-static void test_resolver_finalize (GObject *object);
-
-static gboolean test_resolv_srv (GibberResolver *resolver, guint id,
- const gchar *service_name, const char *service,
- GibberResolverServiceType type);
-
-static void
-test_resolver_class_init (TestResolverClass *test_resolver_class)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (test_resolver_class);
- GibberResolverClass *resolver_class = GIBBER_RESOLVER_CLASS
- (test_resolver_class);
-
- g_type_class_add_private (test_resolver_class, sizeof (TestResolverPrivate));
-
- object_class->dispose = test_resolver_dispose;
- object_class->finalize = test_resolver_finalize;
-
- resolver_class->resolv_srv = test_resolv_srv;
-}
-
-void
-test_resolver_dispose (GObject *object)
-{
- TestResolver *self = TEST_RESOLVER (object);
- TestResolverPrivate *priv = TEST_RESOLVER_GET_PRIVATE (self);
-
- if (priv->dispose_has_run)
- return;
-
- priv->dispose_has_run = TRUE;
-
- /* release any references held by the object here */
-
- if (G_OBJECT_CLASS (test_resolver_parent_class)->dispose)
- G_OBJECT_CLASS (test_resolver_parent_class)->dispose (object);
-}
-
-void
-test_resolver_finalize (GObject *object)
-{
- G_OBJECT_CLASS (test_resolver_parent_class)->finalize (object);
-}
-
-
-static gboolean test_resolv_srv (GibberResolver *resolver, guint id,
- const gchar *service_name, const char *service,
- GibberResolverServiceType type)
-{
- GList *entries = NULL;
- int i;
-
- for (i = 0 ; i < 20 ; i++)
- {
- gchar *str;
-
- str = g_strdup_printf ("test%2d.example.com", i);
-
- entries = g_list_prepend (entries,
- gibber_resolver_srv_record_new (str, 1234,
- 10 - (i / 5) , 4 - i % 5));
-
- g_free (str);
- }
-
- gibber_resolver_srv_result (resolver, id, entries, NULL);
- return FALSE;
-}
diff --git a/tests/test-resolver.h b/tests/test-resolver.h
deleted file mode 100644
index 1d39e4e..0000000
--- a/tests/test-resolver.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * test-resolver.h - Header for TestResolver
- * Copyright (C) 2008 Collabora Ltd.
- * @author Sjoerd Simons <sjoerd.simons at collabora.co.uk>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef __TEST_RESOLVER_H__
-#define __TEST_RESOLVER_H__
-
-#include <glib-object.h>
-#include <gibber/gibber-resolver.h>
-
-G_BEGIN_DECLS
-
-typedef struct _TestResolver TestResolver;
-typedef struct _TestResolverClass TestResolverClass;
-
-struct _TestResolverClass {
- GibberResolverClass parent_class;
-};
-
-struct _TestResolver {
- GibberResolver parent;
-};
-
-GType test_resolver_get_type (void);
-
-/* TYPE MACROS */
-#define TEST_TYPE_RESOLVER \
- (test_resolver_get_type ())
-#define TEST_RESOLVER(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST((obj), TEST_TYPE_RESOLVER, TestResolver))
-#define TEST_RESOLVER_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_RESOLVER, TestResolverClass))
-#define TEST_IS_RESOLVER(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE((obj), TEST_TYPE_RESOLVER))
-#define TEST_IS_RESOLVER_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_RESOLVER))
-#define TEST_RESOLVER_GET_CLASS(obj) \
- (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_RESOLVER, TestResolverClass))
-
-
-G_END_DECLS
-
-#endif /* #ifndef __TEST_RESOLVER_H__*/
diff --git a/tests/test-sasl-auth-server-signals-marshal.list b/tests/test-sasl-auth-server-signals-marshal.list
deleted file mode 100644
index e69de29..0000000
diff --git a/tests/test-sasl-auth-server.c b/tests/test-sasl-auth-server.c
deleted file mode 100644
index 7132122..0000000
--- a/tests/test-sasl-auth-server.c
+++ /dev/null
@@ -1,460 +0,0 @@
-/*
- * test-sasl-auth-server.c - Source for TestSaslAuthServer
- * Copyright (C) 2006 Collabora Ltd.
- * @author Sjoerd Simons <sjoerd at luon.net>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "test-sasl-auth-server.h"
-
-#include <gibber/gibber-xmpp-stanza.h>
-#include <gibber/gibber-xmpp-connection.h>
-#include <gibber/gibber-transport.h>
-
-#include <gibber/gibber-namespaces.h>
-
-#include <sasl/sasl.h>
-
-#define CHECK_SASL_RETURN(x) \
-G_STMT_START { \
- if (x < SASL_OK) { \
- fprintf (stderr, "sasl error (%d): %s\n", \
- ret, sasl_errdetail (priv->sasl_conn)); \
- g_assert_not_reached (); \
- } \
-} G_STMT_END
-
-G_DEFINE_TYPE(TestSaslAuthServer, test_sasl_auth_server, G_TYPE_OBJECT)
-
-#if 0
-/* signal enum */
-enum
-{
- LAST_SIGNAL
-};
-
-static guint signals[LAST_SIGNAL] = {0};
-#endif
-
-typedef enum {
- AUTH_STATE_STARTED,
- AUTH_STATE_CHALLENGE,
- AUTH_STATE_FINAL_CHALLENGE,
- AUTH_STATE_AUTHENTICATED,
-} AuthState;
-
-/* private structure */
-typedef struct _TestSaslAuthServerPrivate TestSaslAuthServerPrivate;
-
-struct _TestSaslAuthServerPrivate
-{
- gboolean dispose_has_run;
- GibberXmppConnection *conn;
- sasl_conn_t *sasl_conn;
- gchar *username;
- gchar *password;
- gchar *mech;
- AuthState state;
- ServerProblem problem;
-};
-
-#define TEST_SASL_AUTH_SERVER_GET_PRIVATE(o) \
- (G_TYPE_INSTANCE_GET_PRIVATE ((o), TEST_TYPE_SASL_AUTH_SERVER, \
- TestSaslAuthServerPrivate))
-
-static void
-test_sasl_auth_server_init (TestSaslAuthServer *obj)
-{
- TestSaslAuthServerPrivate *priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (obj);
- priv->username = NULL;
- priv->password = NULL;
- priv->mech = NULL;
- priv->state = AUTH_STATE_STARTED;
-
- /* allocate any data required by the object here */
-}
-
-static void test_sasl_auth_server_dispose (GObject *object);
-static void test_sasl_auth_server_finalize (GObject *object);
-
-static void
-test_sasl_auth_server_class_init (
- TestSaslAuthServerClass *test_sasl_auth_server_class)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (test_sasl_auth_server_class);
-
- g_type_class_add_private (test_sasl_auth_server_class,
- sizeof (TestSaslAuthServerPrivate));
-
- object_class->dispose = test_sasl_auth_server_dispose;
- object_class->finalize = test_sasl_auth_server_finalize;
-
-}
-
-void
-test_sasl_auth_server_dispose (GObject *object)
-{
- TestSaslAuthServer *self = TEST_SASL_AUTH_SERVER (object);
- TestSaslAuthServerPrivate *priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (self);
-
- if (priv->dispose_has_run)
- return;
-
- priv->dispose_has_run = TRUE;
-
- /* release any references held by the object here */
- g_object_unref (priv->conn);
-
- if (G_OBJECT_CLASS (test_sasl_auth_server_parent_class)->dispose)
- G_OBJECT_CLASS (test_sasl_auth_server_parent_class)->dispose (object);
-}
-
-void
-test_sasl_auth_server_finalize (GObject *object)
-{
- TestSaslAuthServer *self = TEST_SASL_AUTH_SERVER (object);
- TestSaslAuthServerPrivate *priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (self);
-
- /* free any data held directly by the object here */
- g_free (priv->username);
- g_free (priv->password);
- g_free (priv->mech);
-
- G_OBJECT_CLASS (test_sasl_auth_server_parent_class)->finalize (object);
-}
-
-static void
-parse_error (GibberXmppConnection *connection, gpointer user_data)
-{
- fprintf (stderr, "PARSING FAILED IN SASL SERVER\n");
- g_assert_not_reached ();
-}
-
-static void
-stream_opened (GibberXmppConnection *connection, const gchar *to,
- const gchar *from, const gchar *version, gpointer user_data)
-{
- TestSaslAuthServer *self = TEST_SASL_AUTH_SERVER(user_data);
- TestSaslAuthServerPrivate * priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (self);
- GibberXmppStanza *stanza;
- GibberXmppNode *mechnode = NULL;
-
- gibber_xmpp_connection_open (connection, NULL, "testserver", "1.0");
- /* Send stream features */
- stanza = gibber_xmpp_stanza_new ("features");
- gibber_xmpp_node_set_ns (stanza->node, GIBBER_XMPP_NS_STREAM);
-
- if (priv->problem != SERVER_PROBLEM_NO_SASL)
- {
- mechnode = gibber_xmpp_node_add_child_ns (stanza->node,
- "mechanisms", GIBBER_XMPP_NS_SASL_AUTH);
- if (priv->problem == SERVER_PROBLEM_NO_MECHANISMS)
- {
- /* lalala */
- }
- else if (priv->mech != NULL)
- {
- gibber_xmpp_node_add_child_with_content (mechnode, "mechanism",
- priv->mech);
- }
- else
- {
- const gchar *mechs;
- gchar **mechlist;
- gchar **tmp;
- int ret;
- ret = sasl_listmech (priv->sasl_conn, NULL, "","\n","", &mechs,
- NULL,NULL);
- CHECK_SASL_RETURN (ret);
- mechlist = g_strsplit (mechs, "\n", -1);
- for (tmp = mechlist; *tmp != NULL; tmp++)
- {
- gibber_xmpp_node_add_child_with_content (mechnode,
- "mechanism", *tmp);
- }
- g_strfreev (mechlist);
- }
- }
-
- g_assert (gibber_xmpp_connection_send (connection, stanza, NULL));
- g_object_unref (stanza);
-}
-
-static void
-stream_closed (GibberXmppConnection *connection, gpointer user_data)
-{
- gibber_xmpp_connection_close (connection);
-}
-
-static void
-auth_succeeded (TestSaslAuthServer *self)
-{
- TestSaslAuthServerPrivate * priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE(self);
- GibberXmppStanza *s;
-
- g_assert (priv->state < AUTH_STATE_AUTHENTICATED);
- priv->state = AUTH_STATE_AUTHENTICATED;
-
- s = gibber_xmpp_stanza_new ("success");
- gibber_xmpp_node_set_ns (s->node, GIBBER_XMPP_NS_SASL_AUTH);
-
- /* As a result of how the test works, sending out the success will cause the
- * reopening of the stream, so we need to restart the connection first! */
- gibber_xmpp_connection_restart (priv->conn);
-
- g_assert (gibber_xmpp_connection_send (priv->conn, s, NULL));
-
- g_object_unref (s);
-}
-
-static void
-handle_auth (TestSaslAuthServer *self, GibberXmppStanza *stanza)
-{
- TestSaslAuthServerPrivate *priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (self);
- const gchar *mech = gibber_xmpp_node_get_attribute (stanza->node,
- "mechanism");
- guchar *response = NULL;
- const gchar *challenge;
- unsigned challenge_len;
- gsize response_len = 0;
- int ret;
-
- if (stanza->node->content != NULL)
- {
- response = g_base64_decode (stanza->node->content, &response_len);
- }
-
- g_assert (priv->state == AUTH_STATE_STARTED);
- priv->state = AUTH_STATE_CHALLENGE;
-
-
- ret = sasl_server_start (priv->sasl_conn, mech, (gchar *) response,
- (unsigned) response_len, &challenge, &challenge_len);
-
- CHECK_SASL_RETURN (ret);
- if (challenge_len > 0)
- {
- GibberXmppStanza *c;
- gchar *challenge64;
-
- if (ret == SASL_OK)
- {
- priv->state = AUTH_STATE_FINAL_CHALLENGE;
- }
-
- challenge64 = g_base64_encode ((guchar *) challenge, challenge_len);
-
- c = gibber_xmpp_stanza_new ("challenge");
- gibber_xmpp_node_set_ns (c->node, GIBBER_XMPP_NS_SASL_AUTH);
- gibber_xmpp_node_set_content (c->node, challenge64);
- g_assert (gibber_xmpp_connection_send (priv->conn, c, NULL));
- g_object_unref (c);
-
- g_free (challenge64);
- }
- else if (ret == SASL_OK)
- {
- auth_succeeded (self);
- }
- else
- {
- g_assert_not_reached ();
- }
-
- g_free (response);
-}
-
-static void
-handle_response (TestSaslAuthServer *self, GibberXmppStanza *stanza)
-{
- TestSaslAuthServerPrivate * priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (self);
- guchar *response = NULL;
- const gchar *challenge;
- unsigned challenge_len;
- gsize response_len = 0;
- int ret;
-
-
- if (priv->state == AUTH_STATE_FINAL_CHALLENGE)
- {
- g_assert (stanza->node->content == NULL);
- auth_succeeded (self);
- return;
- }
-
- g_assert (priv->state == AUTH_STATE_CHALLENGE);
-
- if (stanza->node->content != NULL)
- {
- response = g_base64_decode (stanza->node->content, &response_len);
- }
-
- ret = sasl_server_step (priv->sasl_conn, (gchar *) response,
- (unsigned) response_len, &challenge, &challenge_len);
-
- CHECK_SASL_RETURN (ret);
-
- if (challenge_len > 0)
- {
- GibberXmppStanza *c;
- gchar *challenge64;
-
- if (ret == SASL_OK)
- {
- priv->state = AUTH_STATE_FINAL_CHALLENGE;
- }
-
- challenge64 = g_base64_encode ((guchar *) challenge, challenge_len);
-
- c = gibber_xmpp_stanza_new ("challenge");
- gibber_xmpp_node_set_ns (c->node, GIBBER_XMPP_NS_SASL_AUTH);
- gibber_xmpp_node_set_content (c->node, challenge64);
- g_assert (gibber_xmpp_connection_send (priv->conn, c, NULL));
- g_object_unref (c);
-
- g_free (challenge64);
- }
- else if (ret == SASL_OK)
- {
- auth_succeeded (self);
- }
- else
- {
- g_assert_not_reached ();
- }
-
- g_free (response);
-}
-
-#define HANDLE(x) { #x, handle_##x }
-static void
-received_stanza (GibberXmppConnection *connection, GibberXmppStanza *stanza,
- gpointer user_data)
-{
- TestSaslAuthServer *self = TEST_SASL_AUTH_SERVER (user_data);
- int i;
- struct {
- const gchar *name;
- void (*func)(TestSaslAuthServer *self, GibberXmppStanza *stanza);
- } handlers[] = { HANDLE(auth), HANDLE(response) };
-
- if (strcmp (gibber_xmpp_node_get_ns (stanza->node),
- GIBBER_XMPP_NS_SASL_AUTH))
- {
- g_assert_not_reached ();
- }
-
- for (i = 0 ; handlers[i].name != NULL; i++)
- {
- if (!strcmp (stanza->node->name, handlers[i].name))
- {
- handlers[i].func (self, stanza);
- return;
- }
- }
-
- g_assert_not_reached ();
-}
-
-static int
-test_sasl_server_auth_log (void *context, int level, const gchar *message)
-{
- return SASL_OK;
-}
-
-static int
-test_sasl_server_auth_getopt (void *context, const char *plugin_name,
- const gchar *option, const gchar **result, guint *len)
-{
- int i;
- static const struct {
- const gchar *name;
- const gchar *value;
- } options[] = {
- { "auxprop_plugin", "sasldb"},
- { "sasldb_path", "./sasl-test.db"},
- { NULL, NULL },
- };
-
- for (i = 0; options[i].name != NULL; i++)
- {
- if (!strcmp (option, options[i].name))
- {
- *result = options[i].value;
- if (len != NULL)
- *len = strlen (options[i].value);
- }
- }
-
- return SASL_OK;
-}
-
-TestSaslAuthServer *
-test_sasl_auth_server_new (GibberTransport *transport, gchar *mech,
- const gchar *user, const gchar *password, ServerProblem problem)
-{
- TestSaslAuthServer *server;
- TestSaslAuthServerPrivate *priv;
- static gboolean sasl_initialized = FALSE;
- int ret;
- static sasl_callback_t callbacks[] = {
- { SASL_CB_LOG, test_sasl_server_auth_log, NULL },
- { SASL_CB_GETOPT, test_sasl_server_auth_getopt, NULL },
- { SASL_CB_LIST_END, NULL, NULL },
- };
-
- if (!sasl_initialized)
- {
- sasl_server_init (NULL, NULL);
- sasl_initialized = TRUE;
- }
-
- server = g_object_new (TEST_TYPE_SASL_AUTH_SERVER, NULL);
- priv = TEST_SASL_AUTH_SERVER_GET_PRIVATE (server);
-
- priv->state = AUTH_STATE_STARTED;
-
- ret = sasl_server_new ("xmpp", NULL, NULL, NULL, NULL, callbacks,
- SASL_SUCCESS_DATA, &(priv->sasl_conn));
- CHECK_SASL_RETURN (ret);
-
- ret = sasl_setpass (priv->sasl_conn, user, password, strlen (password),
- NULL, 0, SASL_SET_CREATE);
-
- CHECK_SASL_RETURN (ret);
-
- priv->username = g_strdup (user);
- priv->password = g_strdup (password);
- priv->mech = g_strdup (mech);
- priv->problem = problem;
-
- priv->conn = gibber_xmpp_connection_new (transport);
- g_signal_connect (priv->conn, "parse-error",
- G_CALLBACK (parse_error), server);
- g_signal_connect (priv->conn, "stream-opened",
- G_CALLBACK (stream_opened), server);
- g_signal_connect (priv->conn, "stream-closed",
- G_CALLBACK (stream_closed), server);
- g_signal_connect (priv->conn, "received-stanza",
- G_CALLBACK (received_stanza), server);
-
- return server;
-}
diff --git a/tests/test-sasl-auth-server.h b/tests/test-sasl-auth-server.h
deleted file mode 100644
index cbfe95e..0000000
--- a/tests/test-sasl-auth-server.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * test-sasl-auth-server.h - Header for TestSaslAuthServer
- * Copyright (C) 2006 Collabora Ltd.
- * @author Sjoerd Simons <sjoerd at luon.net>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef __TEST_SASL_AUTH_SERVER_H__
-#define __TEST_SASL_AUTH_SERVER_H__
-
-#include <glib-object.h>
-
-#include <gibber/gibber-transport.h>
-
-G_BEGIN_DECLS
-
-typedef enum {
- SERVER_PROBLEM_NO_PROBLEM,
- SERVER_PROBLEM_NO_SASL,
- SERVER_PROBLEM_NO_MECHANISMS,
-} ServerProblem;
-
-typedef struct _TestSaslAuthServer TestSaslAuthServer;
-typedef struct _TestSaslAuthServerClass TestSaslAuthServerClass;
-
-struct _TestSaslAuthServerClass {
- GObjectClass parent_class;
-};
-
-struct _TestSaslAuthServer {
- GObject parent;
-};
-
-GType test_sasl_auth_server_get_type (void);
-
-/* TYPE MACROS */
-#define TEST_TYPE_SASL_AUTH_SERVER \
- (test_sasl_auth_server_get_type ())
-#define TEST_SASL_AUTH_SERVER(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST((obj), TEST_TYPE_SASL_AUTH_SERVER, \
- TestSaslAuthServer))
-#define TEST_SASL_AUTH_SERVER_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_SASL_AUTH_SERVER, \
- TestSaslAuthServerClass))
-#define TEST_IS_SASL_AUTH_SERVER(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE((obj), TEST_TYPE_SASL_AUTH_SERVER))
-#define TEST_IS_SASL_AUTH_SERVER_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_SASL_AUTH_SERVER))
-#define TEST_SASL_AUTH_SERVER_GET_CLASS(obj) \
- (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_SASL_AUTH_SERVER, \
- TestSaslAuthServerClass))
-
-
-TestSaslAuthServer * test_sasl_auth_server_new (GibberTransport *transport,
- gchar *mech, const gchar *user, const gchar *password,
- ServerProblem problem);
-
-G_END_DECLS
-
-#endif /* #ifndef __TEST_SASL_AUTH_SERVER_H__*/
diff --git a/tests/test-transport.c b/tests/test-transport.c
deleted file mode 100644
index 78bd566..0000000
--- a/tests/test-transport.c
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * test-transport.c - Source for TestTransport
- * Copyright (C) 2006 Collabora Ltd.
- * @author Sjoerd Simons <sjoerd at luon.net>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#include "test-transport.h"
-
-static gboolean
-test_transport_send (GibberTransport *transport, const guint8 *data,
- gsize size, GError **error);
-
-void test_transport_disconnect (GibberTransport *transport);
-
-G_DEFINE_TYPE (TestTransport, test_transport, GIBBER_TYPE_TRANSPORT)
-
-/* private structure */
-typedef struct _TestTransportPrivate TestTransportPrivate;
-
-struct _TestTransportPrivate
-{
- gboolean dispose_has_run;
- test_transport_send_hook send;
- GQueue *buffers;
- guint send_id;
- gpointer user_data;
-
- gboolean echoing;
-};
-
-#define TEST_TRANSPORT_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
- TEST_TYPE_TRANSPORT, TestTransportPrivate))
-
-static void
-test_transport_init (TestTransport *obj)
-{
- TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (obj);
-
- /* allocate any data required by the object here */
- priv->send = NULL;
- priv->buffers = g_queue_new ();
- priv->send_id = 0;
-}
-
-static void test_transport_dispose (GObject *object);
-static void test_transport_finalize (GObject *object);
-
-static void
-test_transport_class_init (TestTransportClass *test_transport_class)
-{
- GObjectClass *object_class = G_OBJECT_CLASS (test_transport_class);
- GibberTransportClass *transport_class =
- GIBBER_TRANSPORT_CLASS(test_transport_class);
-
- g_type_class_add_private (test_transport_class, sizeof (TestTransportPrivate));
-
- object_class->dispose = test_transport_dispose;
- object_class->finalize = test_transport_finalize;
-
- transport_class->send = test_transport_send;
- transport_class->disconnect = test_transport_disconnect;
-}
-
-void
-test_transport_dispose (GObject *object)
-{
- TestTransport *self = TEST_TRANSPORT (object);
- TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (self);
-
- if (priv->dispose_has_run)
- return;
-
- if (priv->send_id != 0)
- g_source_remove (priv->send_id);
-
- priv->dispose_has_run = TRUE;
-
- /* release any references held by the object here */
-
- if (G_OBJECT_CLASS (test_transport_parent_class)->dispose)
- G_OBJECT_CLASS (test_transport_parent_class)->dispose (object);
-}
-
-static void
-free_array (gpointer data, gpointer user_data)
-{
- g_array_free ((GArray *) data, TRUE);
-}
-
-void
-test_transport_finalize (GObject *object)
-{
- TestTransport *self = TEST_TRANSPORT (object);
- TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (self);
-
- /* free any data held directly by the object here */
- g_queue_foreach (priv->buffers, free_array, NULL);
- g_queue_free (priv->buffers);
- G_OBJECT_CLASS (test_transport_parent_class)->finalize (object);
-}
-
-static gboolean
-send_data (gpointer data)
-{
- TestTransport *self = TEST_TRANSPORT (data);
- TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (self);
- GArray *arr;
-
- g_assert (priv->send != NULL);
-
- arr = (GArray *) g_queue_pop_head (priv->buffers);
-
- priv->send (GIBBER_TRANSPORT (self),
- (guint8 *) arr->data, arr->len, NULL, priv->user_data);
-
- g_array_free (arr, TRUE);
-
- if (g_queue_is_empty (priv->buffers))
- {
- priv->send_id = 0;
- return FALSE;
- }
-
- return TRUE;
-}
-
-static gboolean
-test_transport_send (GibberTransport *transport,
- const guint8 *data, gsize size, GError **error)
-{
- TestTransport *self = TEST_TRANSPORT (transport);
- TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (self);
-
- GArray *arr;
-
- if (priv->echoing)
- {
- test_transport_write (self, data, size);
- }
-
- arr = g_array_sized_new (FALSE, TRUE, sizeof (guint8), size);
- g_array_append_vals (arr, data, size);
-
- g_queue_push_tail (priv->buffers, arr);
-
- if (priv->send_id == 0)
- {
- priv->send_id = g_idle_add (send_data, transport);
- }
-
- return TRUE;
-}
-
-void
-test_transport_disconnect (GibberTransport *transport)
-{
- gibber_transport_set_state (GIBBER_TRANSPORT(transport),
- GIBBER_TRANSPORT_DISCONNECTED);
-}
-
-
-TestTransport *
-test_transport_new (test_transport_send_hook send_, gpointer user_data)
-{
- TestTransport *self;
- TestTransportPrivate *priv;
-
- self = g_object_new (TEST_TYPE_TRANSPORT, NULL);
- priv = TEST_TRANSPORT_GET_PRIVATE (self);
- priv->send = send_;
- priv->user_data = user_data;
-
- gibber_transport_set_state (GIBBER_TRANSPORT(self),
- GIBBER_TRANSPORT_CONNECTED);
-
- return self;
-}
-
-void
-test_transport_set_echoing (TestTransport *transport, gboolean echo)
-{
- TestTransportPrivate *priv = TEST_TRANSPORT_GET_PRIVATE (transport);
- priv->echoing = echo;
-}
-
-
-void
-test_transport_write (TestTransport *transport, const guint8 *buf, gsize size)
-{
- gibber_transport_received_data (GIBBER_TRANSPORT (transport), buf, size);
-}
diff --git a/tests/test-transport.h b/tests/test-transport.h
deleted file mode 100644
index 1e76d13..0000000
--- a/tests/test-transport.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * test-transport.h - Header for TestTransport
- * Copyright (C) 2006 Collabora Ltd.
- * @author Sjoerd Simons <sjoerd at luon.net>
- *
- * 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, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef __TEST_TRANSPORT_H__
-#define __TEST_TRANSPORT_H__
-
-#include <glib-object.h>
-
-#include <gibber/gibber-transport.h>
-
-G_BEGIN_DECLS
-
-typedef struct _TestTransport TestTransport;
-typedef struct _TestTransportClass TestTransportClass;
-
-struct _TestTransportClass {
- GibberTransportClass parent_class;
-};
-
-struct _TestTransport {
- GibberTransport parent;
-};
-
-GType test_transport_get_type (void);
-
-/* TYPE MACROS */
-#define TEST_TYPE_TRANSPORT \
- (test_transport_get_type ())
-#define TEST_TRANSPORT(obj) \
- (G_TYPE_CHECK_INSTANCE_CAST((obj), TEST_TYPE_TRANSPORT, TestTransport))
-#define TEST_TRANSPORT_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_CAST((klass), TEST_TYPE_TRANSPORT, TestTransportClass))
-#define TEST_IS_TRANSPORT(obj) \
- (G_TYPE_CHECK_INSTANCE_TYPE((obj), TEST_TYPE_TRANSPORT))
-#define TEST_IS_TRANSPORT_CLASS(klass) \
- (G_TYPE_CHECK_CLASS_TYPE((klass), TEST_TYPE_TRANSPORT))
-#define TEST_TRANSPORT_GET_CLASS(obj) \
- (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_TRANSPORT, TestTransportClass))
-
-typedef gboolean (*test_transport_send_hook)(GibberTransport *transport,
- const guint8 *data,
- gsize length,
- GError **error,
- gpointer user_data);
-TestTransport *test_transport_new (test_transport_send_hook send,
- gpointer user_data);
-
-void test_transport_set_echoing (TestTransport *transport,
- gboolean echo);
-
-void test_transport_write (TestTransport *transport,
- const guint8 *buf, gsize size);
-
-G_END_DECLS
-
-#endif /* #ifndef __TEST_TRANSPORT_H__*/
diff --git a/tests/test-xmpp-connection.c b/tests/test-xmpp-connection.c
deleted file mode 100644
index 71e5e2b..0000000
--- a/tests/test-xmpp-connection.c
+++ /dev/null
@@ -1,157 +0,0 @@
-#include <stdio.h>
-#include <unistd.h>
-#include <glib.h>
-
-#include <gibber/gibber-xmpp-connection.h>
-#include <gibber/gibber-transport.h>
-#include "test-transport.h"
-
-#define BUFSIZE 10
-
-FILE *treefile = NULL;
-FILE *xmlfile = NULL;
-gboolean parsing_failed = FALSE;
-
-static gboolean
-send_hook (GibberTransport *transport, const guint8 *data,
- gsize length, GError **error, gpointer user_data)
-{
- size_t written;
- /* Nothing for now */
- written = fwrite (data, 1, length, xmlfile);
- g_assert (written == length);
- return TRUE;
-}
-
-static void
-parse_error (GibberXmppConnection *connection, gpointer user_data)
-{
- fprintf (treefile, "PARSE ERROR\n");
- fprintf (stderr, "PARSING FAILED\n");
- parsing_failed = TRUE;
-}
-
-static void
-stream_opened (GibberXmppConnection *connection, const gchar *to,
- const gchar *from, const gchar *version, gpointer user_data)
-{
- fprintf (treefile, "STREAM OPENED to=%s from=%s version=%s\n", to, from,
- version);
-
- gibber_xmpp_connection_open (connection, to, from, version);
-}
-
-static void
-stream_closed (GibberXmppConnection *connection, gpointer user_data)
-{
- fprintf (treefile, "STREAM CLOSED\n");
- gibber_xmpp_connection_close (connection);
-}
-
-static gboolean
-print_attribute (const gchar *key, const gchar *value, const gchar *ns,
- gpointer user_data)
-{
- fprintf (treefile, "%*s |-- Attribute: %s -> %s (ns: %s)\n",
- GPOINTER_TO_INT (user_data), " ", key, value, ns);
- return TRUE;
-}
-
-static void print_node (GibberXmppNode *node, gint ident);
-
-static gboolean
-print_child (GibberXmppNode *node, gpointer user_data)
-{
- print_node (node, GPOINTER_TO_INT(user_data));
- return TRUE;
-}
-
-static void
-print_node (GibberXmppNode *node, gint ident)
-{
- fprintf (treefile, "%*s`-+-- Name: %s (ns: %s)\n", ident - 1, " ",
- node->name, gibber_xmpp_node_get_ns (node));
- gibber_xmpp_node_each_attribute (node, print_attribute,
- GINT_TO_POINTER(ident));
-
- if (node->content)
- fprintf (treefile, "%*s |-- Content: %s\n", ident, " ", node->content);
- if (gibber_xmpp_node_get_language (node))
- fprintf (treefile, "%*s |-- Language: %s\n", ident, " ",
- gibber_xmpp_node_get_language (node));
-
- gibber_xmpp_node_each_child (node, print_child, GINT_TO_POINTER (ident + 2));
-}
-
-static void
-received_stanza (GibberXmppConnection *connection, GibberXmppStanza *stanza,
- gpointer user_data)
-{
- fprintf (treefile, "-|\n");
- print_node (stanza->node, 2);
- g_assert (gibber_xmpp_connection_send (connection, stanza, NULL));
-}
-
-int
-main (int argc, char **argv)
-{
- GibberXmppConnection *connection;
- TestTransport *transport;
- FILE *file;
- int ret = 0;
- guint8 buf[BUFSIZE];
-
-
- g_type_init ();
-
- transport = test_transport_new (send_hook, NULL);
- connection = gibber_xmpp_connection_new (GIBBER_TRANSPORT(transport));
-
- g_signal_connect (connection, "parse-error",
- G_CALLBACK (parse_error), NULL);
- g_signal_connect (connection, "stream-opened",
- G_CALLBACK (stream_opened), NULL);
- g_signal_connect (connection, "stream-closed",
- G_CALLBACK (stream_closed), NULL);
- g_signal_connect (connection, "received-stanza",
- G_CALLBACK (received_stanza), NULL);
-
- g_assert (argc >= 2 && argc < 5);
-
- file = fopen (argv[1], "r");
- g_assert (file != NULL);
-
- if (argc >= 3)
- {
- treefile = fopen (argv[2], "w+");
- }
- else
- {
- treefile = stdout;
- }
- g_assert (treefile != NULL);
-
- if (argc >= 4)
- {
- xmlfile = fopen (argv[3], "w+");
- }
- else
- {
- xmlfile = stderr;
- }
- g_assert (xmlfile != NULL);
-
- while (!parsing_failed && (ret = fread (buf, 1, BUFSIZE, file)) > 0)
- {
- test_transport_write (transport, buf, ret);
- }
-
- while (g_main_context_iteration (NULL, FALSE))
- ;
-
-
- g_assert (parsing_failed || ret == 0);
- fclose (file);
-
- return parsing_failed ? 1 : 0;
-}
--
1.5.6.5
More information about the telepathy-commits
mailing list