common: New function tokenize_to_strlist.

* common/strlist.c (append_to_strlist_try): Factor code out to ...
(do_append_to_strlist): new.
(tokenize_to_strlist): New.

* common/t-strlist.c (test_tokenize_to_strlist): New.

1 files changed, 189 insertions, 0 deletions

diff --git a/common/t-strlist.c b/common/t-strlist.c
index fdbeb9b99..65fc52420 100644
--- a/common/t-strlist.c
+++ b/common/t-strlist.c
@@ -72,6 +72,194 @@ test_strlist_rev (void)
 }
 
 
+static void
+test_tokenize_to_strlist (void)
+{
+  struct {
+    const char *s;
+    const char *delim;
+    int error_expected;
+    const char *items_expected[10];
+  } tv[] = {
+    {
+      "", ":",
+      1, { NULL }
+    },
+    {
+      "a", ":",
+      0, { "a", NULL }
+    },
+    {
+      ":", ":",
+      1, { NULL }
+    },
+    {
+      "::", ":",
+      1, { NULL }
+    },
+    {
+      "a:b:c", ":",
+      0, { "a", "b", "c", NULL }
+    },
+    {
+      "a:b:", ":",
+      0, { "a", "b", NULL }
+    },
+    {
+      "a:b", ":",
+      0, { "a", "b", NULL }
+    },
+    {
+      "aa:b:cd", ":",
+      0, { "aa", "b", "cd", NULL }
+    },
+    {
+      "aa::b:cd", ":",
+      0, { "aa", "b", "cd", NULL }
+    },
+    {
+      "::b:cd", ":",
+      0, { "b", "cd", NULL }
+    },
+    {
+      "aa:   : b:cd ", ":",
+      0, { "aa", "b", "cd", NULL }
+    },
+    {
+      "  aa:   : b:  cd ", ":",
+      0, { "aa", "b", "cd", NULL }
+    },
+    {
+      "  :", ":",
+      1, { NULL }
+    },
+    {
+      "  : ", ":",
+      1, { NULL }
+    },
+    {
+      ": ", ":",
+      1, { NULL }
+    },
+    {
+      ": x ", ":",
+      0, { "x", NULL }
+    },
+    {
+      "a:bc:cde:fghi:jklmn::foo:", ":",
+      0, { "a", "bc", "cde", "fghi", "jklmn", "foo", NULL }
+    },
+    {
+      ",a,bc,,def,", ",",
+      0, { "a", "bc", "def", NULL }
+    },
+    {
+      " a ", " ",
+      0, { "a", NULL }
+    },
+    {
+      " ", " ",
+      1, { NULL }
+    },
+    {
+      "a:bc:c de:fg   hi:jklmn::foo :", ":",
+      0, { "a", "bc", "c de", "fg   hi", "jklmn", "foo", NULL }
+    },
+    {
+      "", " ",
+      1, { NULL }
+    }
+  };
+  const char *prefixes[3] = { "abc", "bcd", "efg" };
+  int tidx;
+  int nprefixes; /* Number of items in already in the list.  */
+  strlist_t list = NULL;
+
+  for (nprefixes = 0; nprefixes < DIM (prefixes); nprefixes++)
+    for (tidx = 0; tidx < DIM(tv); tidx++)
+      {
+        int item_count_expected;
+        int i;
+        strlist_t sl, newitems;
+
+        for (item_count_expected = 0;
+             tv[tidx].items_expected[item_count_expected];
+             item_count_expected++)
+          ;
+
+        /* printf  ("np=%d testing %d \"%s\" delim=\"%s\"\n", */
+        /*          nprefixes, tidx, tv[tidx].s, tv[tidx].delim); */
+        for (i=0; i < nprefixes; i++)
+          append_to_strlist (&list, prefixes[i]);
+
+        newitems = tokenize_to_strlist (&list, tv[tidx].s, tv[tidx].delim);
+        if (!newitems)
+          {
+            if (gpg_err_code_from_syserror () == GPG_ERR_ENOENT
+                && tv[tidx].error_expected)
+              {
+                /* Good.  But need to check the prefixes.  */
+                for (sl=list, i=0; i < nprefixes; i++, sl=sl->next)
+                  {
+                    if (!sl || strcmp (prefixes[i], sl->d))
+                      {
+                        printf ("For item %d prefix item %d, expected '%s'\n",
+                                tidx, i, prefixes[i]);
+                        fail (tidx * 1000 + 40 + i + 1);
+                      }
+                  }
+              }
+            else
+              fail (tidx * 1000);
+          }
+        else if (tv[tidx].error_expected)
+          {
+            printf ("got items");
+            for (sl = list; sl; sl = sl->next)
+              printf (" \"%s\"", sl->d);
+            printf ("\n");
+            fail (tidx * 1000);
+          }
+        else
+          {
+            if (strlist_length (list) != nprefixes + item_count_expected)
+              fail (tidx * 1000);
+            else
+              {
+                for (sl=list, i=0; i < nprefixes; i++, sl=sl->next)
+                  {
+                    if (!sl || strcmp (prefixes[i], sl->d))
+                      {
+                        printf ("For item %d prefix item %d, expected '%s'\n",
+                                tidx, i, prefixes[i]);
+                        fail (tidx * 1000 + 50 + i + 1);
+                      }
+                  }
+                for (i=0; i < item_count_expected; i++, sl=sl->next)
+                  {
+                    if (!sl)
+                      {
+                        printf ("No item at item index %d\n", i);
+                        fail (tidx * 1000 + i + 0);
+                        break;
+                      }
+                    if (strcmp (tv[tidx].items_expected[i], sl->d))
+                      {
+                        printf ("For item %d, expected '%s', but got '%s'\n",
+                                i, tv[tidx].items_expected[i], sl->d);
+                        fail (tidx * 1000 + 10 + i + 1);
+                      }
+                  }
+              }
+          }
+
+        free_strlist (list);
+        list = NULL;
+      }
+}
+
+
+
 int
 main (int argc, char **argv)
 {
@@ -79,6 +267,7 @@ main (int argc, char **argv)
   (void)argv;
 
   test_strlist_rev ();
+  test_tokenize_to_strlist ();
 
   return 0;
 }