#include <stdlib.h>

 #include <stdio.h>

 #include <string.h>

 #include "lib/url.h"

 #define FAIL(...) do { printf("FAIL: "); printf(__VA_ARGS__); printf("\n"); return -1; } while (0)

 struct url_schema

     basic_http = { 1, { "http" } },

     svn_ssh = { 2, { "svn", "ssh" } },

     schema_unix = { 1, { "unix" } }

     ;

 struct url_opts

     opts_single = { 1, { { "key0", "val0" } } },

     opts_multi = { 2, { { "key0", "val0" }, { "key1", "val1" } } },

     opts_nullval = { 1, { { "keyN", NULL } } }

     ;

 struct url_test {

     const char *url;

     const struct url expected;

 } url_tests[] = {

     {   "localhost:http",   {

         NULL, NULL, NULL, "localhost", "http", NULL, NULL

     } },

     {   "http://example.com/path",  {

         &basic_http, NULL, NULL, "example.com", NULL, "path", NULL 

     } },

     {   "svn+ssh://user:passwd@someplace:someport/something",   {

         &svn_ssh, "user", "passwd", "someplace", "someport", "something"

     } },

     {   "user@:service/",   {

         NULL, "user", NULL, NULL, "service", NULL

     } },

     {   "unix:////tmp/foo.sock",    {

         &schema_unix, NULL, NULL, NULL, NULL, "/tmp/foo.sock"

     } },

     {   "unix:///tmp/foo.sock", {

         &schema_unix, NULL, NULL, NULL, NULL, "tmp/foo.sock"

     } },

     {   "/tmp/foo.sock",    {

         NULL, NULL, NULL, NULL, NULL, "tmp/foo.sock"

     } },

     {   "?key0=val0",   {

         NULL, NULL, NULL, NULL, NULL, NULL, &opts_single

     } },

     {   "http://foo.com/index.php?key0=val0&key1=val1",  {

         &basic_http, NULL, NULL, "foo.com", NULL, "index.php", &opts_multi

     } },

     {   "example.org:81/?keyN", {

         NULL, NULL, NULL, "example.org", "81", NULL, &opts_nullval

     } },

     {   NULL,               {   } },

 };

 int cmp_url_str (const char *field, const char *test, const char *real) {

     if (!test) {

         if (real)

             FAIL("%s shouldn't be present", field);

     } else if (!real) {

         FAIL("%s is missing", field);

     } else {

         if (strcmp(test, real) != 0)

             FAIL("%s differs: %s -> %s", field, test, real);

     }

     // ok

     return 0;

 }

 int cmp_url (const struct url *test, const struct url *real) {

     int i;

     // test schema

     if (!test->schema) {

         if (real->schema)

             FAIL("test has no schema, but real does");

     } else if (!real->schema) {

         FAIL("test has a schema, but real doesn't");

     } else {

         if (test->schema->count != test->schema->count)

             FAIL("inconsistent scheme count");

         for (i = 0; i < test->schema->count; i++) {

             if (strcmp(test->schema->list[i], real->schema->list[i]) != 0)

                 FAIL("differing scheme #%d", i);

         }

     }

     // test username

     if (cmp_url_str("username", test->username, real->username))

         goto error;

     // test password

     if (cmp_url_str("password", test->password, real->password))

         goto error;

     // test hostname

     if (cmp_url_str("hostname", test->hostname, real->hostname))

         goto error;

     // test service

     if (cmp_url_str("service", test->service, real->service))

         goto error;

     // test path

     if (cmp_url_str("path", test->path, real->path))

         goto error;

     // test query

     if (!test->opts) {

         if (real->opts)

             FAIL("test has no opts, but real does");

     } else if (!real->opts) {

         FAIL("test has opts, but real doesn't");

     } else {

         if (test->opts->count != test->opts->count)

             FAIL("inconsistent opts count");

         for (i = 0; i < test->opts->count; i++) {

             if (cmp_url_str("opt key", test->opts->list[i].key, real->opts->list[i].key))

                 FAIL("differing opt key #%d", i);

             if (cmp_url_str("opt value", test->opts->list[i].value, real->opts->list[i].value))

                 FAIL("differing opt value #%d", i);

         }

     }

     // ok

     return 0;

 error:

     return -1;

 }

 void usage (const char *exec_name) {

     printf("Usage: %s\n\n\tNo arguments are accepted\n", exec_name);

     exit(EXIT_FAILURE);

 }

 int main (int argc, char **argv) {

     const struct url_test *test;

     struct url url;

     if (argc > 1)

         usage(argv[0]);

     // run the tests

     for (test = url_tests; test->url; test++) {

         // first output the URL we are handling...

         printf("%-80s - ", test->url);

         fflush(stdout);

         // parse the URL

         memset(&url, 0, sizeof(url));

         if (url_parse(&url, test->url)) {

             printf("FATAL: url_parse failed\n");

             return EXIT_FAILURE;

         }

         // compare it

         if (cmp_url(&test->expected, &url)) {

             printf("\texpected: ");

             url_dump(&test->expected, stdout);

             printf("\tresult:   ");

             url_dump(&url, stdout);

         } else {

             printf("OK\n\t");

             url_dump(&url, stdout);

         }

         printf("\n");

     }

 }