Remove obsolete enumerator/linked_list tests in unit_tester plugin
authorTobias Brunner <tobias@strongswan.org>
Tue, 26 Mar 2013 12:13:33 +0000 (13:13 +0100)
committerTobias Brunner <tobias@strongswan.org>
Tue, 11 Jun 2013 09:03:10 +0000 (11:03 +0200)
src/libcharon/plugins/unit_tester/Makefile.am
src/libcharon/plugins/unit_tester/tests.h
src/libcharon/plugins/unit_tester/tests/test_enumerator.c [deleted file]

index c46d2b8..ec98dc6 100644 (file)
@@ -12,7 +12,6 @@ endif
 
 libstrongswan_unit_tester_la_SOURCES = \
        unit_tester.c unit_tester.h tests.h \
-       tests/test_enumerator.c \
        tests/test_auth_info.c \
        tests/test_curl.c \
        tests/test_mysql.c \
index cd38c8a..bc7e174 100644 (file)
  * @{ @ingroup unit_tester
  */
 
-DEFINE_TEST("linked_list_t->remove()", test_list_remove, FALSE)
 DEFINE_TEST("hashtable_t->remove_at()", test_hashtable_remove_at, FALSE)
-DEFINE_TEST("simple enumerator", test_enumerate, FALSE)
-DEFINE_TEST("nested enumerator", test_enumerate_nested, FALSE)
-DEFINE_TEST("filtered enumerator", test_enumerate_filtered, FALSE)
-DEFINE_TEST("token enumerator", test_enumerate_token, FALSE)
 DEFINE_TEST("auth cfg", test_auth_cfg, FALSE)
 DEFINE_TEST("CURL get", test_curl_get, FALSE)
 DEFINE_TEST("MySQL operations", test_mysql, FALSE)
diff --git a/src/libcharon/plugins/unit_tester/tests/test_enumerator.c b/src/libcharon/plugins/unit_tester/tests/test_enumerator.c
deleted file mode 100644 (file)
index 83b78c0..0000000
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- * Copyright (C) 2007 Martin Willi
- * Hochschule fuer Technik Rapperswil
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License as published by the
- * Free Software Foundation; either version 2 of the License, or (at your
- * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
- *
- * This program 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 General Public License
- * for more details.
- */
-
-#include <collections/linked_list.h>
-
-
-/*******************************************************************************
- * linked list remove test
- ******************************************************************************/
-bool test_list_remove()
-{
-       void *a = (void*)1, *b = (void*)2;
-       linked_list_t *list;
-
-       list = linked_list_create();
-       list->insert_last(list, a);
-       if (list->remove(list, a, NULL) != 1)
-       {
-               return FALSE;
-       }
-       list->insert_last(list, a);
-       list->insert_first(list, a);
-       list->insert_last(list, a);
-       list->insert_last(list, b);
-       if (list->remove(list, a, NULL) != 3)
-       {
-               return FALSE;
-       }
-       if (list->remove(list, a, NULL) != 0)
-       {
-               return FALSE;
-       }
-       if (list->get_count(list) != 1)
-       {
-               return FALSE;
-       }
-       if (list->remove(list, b, NULL) != 1)
-       {
-               return FALSE;
-       }
-       if (list->remove(list, b, NULL) != 0)
-       {
-               return FALSE;
-       }
-       list->destroy(list);
-       return TRUE;
-}
-
-/*******************************************************************************
- * Simple insert first/last and enumerate test
- ******************************************************************************/
-bool test_enumerate()
-{
-       int round, x;
-       void *a = (void*)4, *b = (void*)3, *c = (void*)2, *d = (void*)5, *e = (void*)1;
-       linked_list_t *list;
-       enumerator_t *enumerator;
-
-       list = linked_list_create();
-
-       list->insert_last(list, a);
-       list->insert_first(list, b);
-       list->insert_first(list, c);
-       list->insert_last(list, d);
-       list->insert_first(list, e);
-
-       round = 1;
-       enumerator = list->create_enumerator(list);
-       while (enumerator->enumerate(enumerator, &x))
-       {
-               if (round != x)
-               {
-                       return FALSE;
-               }
-               round++;
-       }
-       enumerator->destroy(enumerator);
-
-       list->destroy(list);
-       return TRUE;
-}
-
-/*******************************************************************************
- * nested enumerator test
- ******************************************************************************/
-
-static bool bad_data;
-
-static enumerator_t* create_inner(linked_list_t *outer, void *data)
-{
-       if (data != (void*)101)
-       {
-               bad_data = TRUE;
-       }
-       return outer->create_enumerator(outer);
-}
-
-
-static void destroy_data(void *data)
-{
-       if (data != (void*)101)
-       {
-               bad_data = TRUE;
-       }
-}
-
-bool test_enumerate_nested()
-{
-       int round, x;
-       void *a = (void*)1, *b = (void*)2, *c = (void*)3, *d = (void*)4, *e = (void*)5;
-       linked_list_t *list, *l1, *l2, *l3;
-       enumerator_t *enumerator;
-
-       bad_data = FALSE;
-       list = linked_list_create();
-       l1 = linked_list_create();
-       l2 = linked_list_create();
-       l3 = linked_list_create();
-       list->insert_last(list, l1);
-       list->insert_last(list, l2);
-       list->insert_last(list, l3);
-
-       l1->insert_last(l1, a);
-       l1->insert_last(l1, b);
-       l3->insert_last(l3, c);
-       l3->insert_last(l3, d);
-       l3->insert_last(l3, e);
-
-       round = 1;
-       enumerator = enumerator_create_nested(list->create_enumerator(list),
-                                       (void*)create_inner, (void*)101, destroy_data);
-       while (enumerator->enumerate(enumerator, &x))
-       {
-               if (round != x)
-               {
-                       return FALSE;
-               }
-               round++;
-       }
-       enumerator->destroy(enumerator);
-
-       list->destroy(list);
-       l1->destroy(l1);
-       l2->destroy(l2);
-       l3->destroy(l3);
-       return !bad_data;
-}
-
-
-/*******************************************************************************
- * filtered enumerator test
- ******************************************************************************/
-static bool filter(void *data, int *v, int *vo, int *w, int *wo,
-                                  int *x, int *xo, int *y, int *yo, int *z, int *zo)
-{
-       int val = *v;
-
-       *vo = val++;
-       *wo = val++;
-       *xo = val++;
-       *yo = val++;
-       *zo = val++;
-       if (data != (void*)101)
-       {
-               return FALSE;
-       }
-       return TRUE;
-}
-
-bool test_enumerate_filtered()
-{
-       int round, v, w, x, y, z;
-       void *a = (void*)1, *b = (void*)2, *c = (void*)3, *d = (void*)4, *e = (void*)5;
-       linked_list_t *list;
-       enumerator_t *enumerator;
-
-       bad_data = FALSE;
-       list = linked_list_create();
-
-       list->insert_last(list, a);
-       list->insert_last(list, b);
-       list->insert_last(list, c);
-       list->insert_last(list, d);
-       list->insert_last(list, e);
-
-       round = 1;
-       enumerator = enumerator_create_filter(list->create_enumerator(list),
-                                                                       (void*)filter, (void*)101, destroy_data);
-       while (enumerator->enumerate(enumerator, &v, &w, &x, &y, &z))
-       {
-               if (v != round || w != round + 1 || x != round + 2 ||
-                       y != round + 3 || z != round + 4)
-               {
-                       return FALSE;
-               }
-               round++;
-       }
-       enumerator->destroy(enumerator);
-
-       list->destroy(list);
-       return !bad_data;
-}
-
-/*******************************************************************************
- * token parser test
- ******************************************************************************/
-
-bool test_enumerate_token()
-{
-       enumerator_t *enumerator;
-       char *token;
-       int i, num;
-       struct {
-               char *string;
-               char *sep;
-               char *trim;
-       } tests1[] = {
-               {"abc, cde, efg", ",", " "},
-               {" abc 1:2 cde;3  4efg5.  ", ":;.,", " 12345"},
-               {"abc.cde,efg", ",.", ""},
-               {"  abc   cde  efg  ", " ", " "},
-               {"a'abc' c 'cde' cefg", " ", " abcd"},
-               {"'abc' abc 'cde'd 'efg'", " ", " abcd"},
-       }, tests2[] = {
-               {"a, b, c", ",", " "},
-               {"a,b,c", ",", " "},
-               {" a 1:2 b;3  4c5.  ", ":;.,", " 12345"},
-               {"a.b,c", ",.", ""},
-               {"  a   b  c  ", " ", " "},
-       };
-
-       for (num = 0; num < countof(tests1); num++)
-       {
-               i = 0;
-               enumerator = enumerator_create_token(tests1[num].string,
-                                                                                        tests1[num].sep, tests1[num].trim);
-               while (enumerator->enumerate(enumerator, &token))
-               {
-                       switch (i)
-                       {
-                               case 0:
-                                       if (!streq(token, "abc")) return FALSE;
-                                       break;
-                               case 1:
-                                       if (!streq(token, "cde")) return FALSE;
-                                       break;
-                               case 2:
-                                       if (!streq(token, "efg")) return FALSE;
-                                       break;
-                               default:
-                                       return FALSE;
-                       }
-                       i++;
-               }
-               if (i != 3)
-               {
-                       return FALSE;
-               }
-               enumerator->destroy(enumerator);
-       }
-
-       for (num = 0; num < countof(tests2); num++)
-       {
-               i = 0;
-               enumerator = enumerator_create_token(tests2[num].string,
-                                                                                        tests2[num].sep, tests2[num].trim);
-               while (enumerator->enumerate(enumerator, &token))
-               {
-                       switch (i)
-                       {
-                               case 0:
-                                       if (!streq(token, "a")) return FALSE;
-                                       break;
-                               case 1:
-                                       if (!streq(token, "b")) return FALSE;
-                                       break;
-                               case 2:
-                                       if (!streq(token, "c")) return FALSE;
-                                       break;
-                               default:
-                                       return FALSE;
-                       }
-                       i++;
-               }
-               if (i != 3)
-               {
-                       return FALSE;
-               }
-               enumerator->destroy(enumerator);
-       }
-
-       return TRUE;
-}
-