1

     2

#include <stdlib.h>

     3

#include <stdio.h>

     4

#include <string.h>

     5

     6

#include "lib/url.h"

     7

     8

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

     9

    10

    11

struct url_test {

    12

    const char *url;

    13

    const struct url expected;

    14

} url_tests[] = {

    15

    {   "localhost:http",   {

    16

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

    17

    } },

    18

    19

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

    20

        { 1, { "http" } }, NULL, NULL, "example.com", NULL, "path", NULL 

    21

    } }, */

    22

    23

    {   NULL,               {   } },

    24

};

    25

    26

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

    27

    if (!test) {

    28

        if (real)

    29

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

    30

    31

    } else if (!real) {

    32

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

    33

    34

    } else {

    35

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

    36

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

    37

    }

    38

    39

    // ok

    40

    return 0;

    41

}

    42

    43

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

    44

    int i;

    45

    46

    // test schema

    47

    if (!test->schema) {

    48

        if (real->schema)

    49

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

    50

    51

    } else if (!real->schema) {

    52

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

    53

    54

    } else {

    55

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

    56

            FAIL("inconsistent scheme count");

    57

    58

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

    59

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

    60

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

    61

        }

    62

    }

    63

    64

    // test username

    65

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

    66

        goto error;

    67

    68

    // test password

    69

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

    70

        goto error;

    71

    72

    // test hostname

    73

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

    74

        goto error;

    75

    76

    // test service

    77

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

    78

        goto error;

    79

    80

    // test path

    81

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

    82

        goto error;

    83

    84

    // test query

    85

    if (!test->opts) {

    86

        if (real->opts)

    87

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

    88

    89

    } else if (!real->opts) {

    90

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

    91

    92

    } else {

    93

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

    94

            FAIL("inconsistent opts count");

    95

    96

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

    97

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

    98

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

    99

   100

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

   101

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

   102

        }

   103

    }

   104

   105

    // ok

   106

    return 0;

   107

   108

error:

   109

    return -1;

   110

}

   111

   112

void print_url_part (const char *field, const char *val) {

   113

    if (val) {

   114

        printf("%s=%s ", field, val);

   115

    }

   116

}

   117

   118

void print_url (const struct url *url) {

   119

    int i;

   120

   121

    if (url->schema) {

   122

        printf("schema=");

   123

   124

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

   125

            if (i > 0)

   126

                printf("+");

   127

   128

            printf("%s", url->schema->list[i]);

   129

        }

   130

   131

        printf(" ");

   132

    }

   133

   134

    print_url_part("username", url->username);

   135

    print_url_part("password", url->password);

   136

    print_url_part("hostname", url->hostname);

   137

    print_url_part("service", url->service);

   138

    print_url_part("path", url->path);

   139

   140

    if (url->opts) {

   141

        printf("opts: ");

   142

   143

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

   144

            printf("%s=%s ", url->opts->list[i]->key, url->opts->list[i]->value);

   145

        }

   146

    }

   147

   148

    printf("\n");

   149

}

   150

   151

void usage (const char *exec_name) {

   152

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

   153

   154

    exit(EXIT_FAILURE);

   155

}

   156

   157

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

   158

    const struct url_test *test;

   159

    struct url url;

   160

   161

    if (argc > 1)

   162

        usage(argv[0]);

   163

   164

    // run the tests

   165

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

   166

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

   167

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

   168

        fflush(stdout);

   169

   170

        // parse the URL

   171

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

   172

   173

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

   174

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

   175

            return EXIT_FAILURE;

   176

        }

   177

   178

        // compare it

   179

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

   180

            printf("\texpected: ");

   181

            print_url(&test->expected);

   182

   183

            printf("\tresult:   ");

   184

            print_url(&url);

   185

   186

        } else {

   187

            printf("OK\n\t");

   188

            print_url(&url);

   189

        }

   190

    }

   191

}

   192