1

#include "transport.h"

     2

#include "test.h"

     3

     4

void assert_transport_read (transport_t *transport, const char *str)

     5

{

     6

    size_t len = strlen(str);

     7

    char buf[len];

     8

    error_t err;

     9

    10

    log_debug("read: %p: %s", transport, dump_str(str));

    11

    12

    // read it

    13

    assert(transport_read(transport, buf, len, &err) == (int) len);

    14

    15

    // cmp

    16

    assert_strncmp(buf, str, len);

    17

}

    18

    19

void assert_transport_write (transport_t *transport, const char *str)

    20

{

    21

    size_t len = strlen(str);

    22

    error_t err;

    23

    24

    log_debug("write: %p: %s", transport, dump_str(str));

    25

    26

    // write it

    27

    assert(transport_write(transport, str, len, &err) == (int) len);

    28

}

    29

    30

void assert_transport_eof (transport_t *transport)

    31

{

    32

    char buf;

    33

    error_t err;

    34

    35

    log_debug("eof: %p", transport);

    36

    37

    assert_err(-transport_read(transport, &buf, 1, &err), ERR_EOF);

    38

}

    39

    40

void assert_transport_data (struct transport_test *tp, const char *fmt, ...)

    41

{

    42

    char buf[TRANSPORT_TEST_FMT_MAX];

    43

    va_list vargs;

    44

    size_t len;

    45

    46

    va_start(vargs, fmt);

    47

    48

    if ((len = vsnprintf(buf, sizeof(buf), fmt, vargs)) >= sizeof(buf))

    49

        FATAL("input too long: %zu bytes", len);

    50

    51

    va_end(vargs);

    52

    53

    // get the data out

    54

    char *out;

    55

    56

    transport_test_pull_buf(tp, &out, &len);

    57

    58

    log_debug("pull_buf: %s", dump_strn(out, len));

    59

    60

    // should be the same

    61

    assert_strncmp(out, buf, len);

    62

    assert_strlen(buf, len);

    63

    64

    // cleanup

    65

    free(out);

    66

}

    67

    68

struct transport_test* setup_transport_test (void)

    69

{

    70

    struct transport_test *tp;

    71

    72

    assert ((tp = transport_test_create(NULL)) != NULL);

    73

    74

    return tp;

    75

}

    76

    77

void test_transport_test (void)

    78

{

    79

    struct transport_info info = { NULL, NULL, 0 };

    80

    struct transport_test *tp = transport_test_create(&info);

    81

    transport_t *transport = transport_test_cast(tp);

    82

    83

    // put the read data

    84

    log_info("test transport_test_push_*");

    85

    transport_test_push_buf(tp, "foo", 3);

    86

    transport_test_push_str(tp, "barx");

    87

    transport_test_push_fmt(tp, "xx %s xx", "quux");

    88

    transport_test_push_eof(tp);

    89

    90

    // read it out

    91

    log_info("test transport_test_read");

    92

    93

    assert_transport_read(transport, "foo");

    94

    assert_transport_read(transport, "ba");

    95

    assert_transport_read(transport, "rx");

    96

    assert_transport_read(transport, "xx quux xx");

    97

    assert_transport_eof(transport);

    98

    99

    // write some data in

   100

    log_info("test transport_test_write");

   101

   102

    assert_transport_write(transport, "test ");

   103

    assert_transport_write(transport, "data");

   104

   105

    // check output

   106

    log_info("test transport_test_pull_*");

   107

   108

    assert_transport_data(tp, "test data");

   109

    assert_transport_data(tp, "");

   110

   111

    // cleanup

   112

    transport_test_destroy(tp);

   113

}

   114