testsuite/sexp-format-test.c

   1 #include "testutils.h"
   2 #include "sexp.h"
   3
   4 #include "buffer.h"
   5
   6 #if HAVE_LIBGMP
   7 # include "bignum.h"
   8 #endif
   9
  10 void
  11 test_main(void)
  12 {
  13   struct nettle_buffer buffer;
  14
  15   {
  16     const uint8_t e[] = "(3:foo(3:bar17:xxxxxxxxxxxxxxxxx))";
  17
  18     nettle_buffer_init(&buffer);
  19     ASSERT(sexp_format(&buffer, "(%0s(%0s%0s))",
  20                        "foo", "bar", "xxxxxxxxxxxxxxxxx")
  21            == strlen(e));
  22
  23     ASSERT(sexp_format(NULL, "(%0s(%0s%0s))",
  24                        "foo", "bar", "xxxxxxxxxxxxxxxxx")
  25            == strlen(e));
  26
  27     ASSERT(buffer.size == strlen(e));
  28     ASSERT(MEMEQ(buffer.size, buffer.contents, e));
  29     nettle_buffer_clear(&buffer);
  30   }
  31   {
  32     const uint8_t e[] = "{KDM6Zm9vKDM6YmFyMTc6eHh4eHh4eHh4eHh4eHh4eHgpKQ==}";
  33
  34     nettle_buffer_init(&buffer);
  35     ASSERT(sexp_transport_format(&buffer, "(%0s(%0s%0s))",
  36                        "foo", "bar", "xxxxxxxxxxxxxxxxx")
  37            == strlen(e));
  38
  39     ASSERT(sexp_transport_format(NULL, "(%0s(%0s%0s))",
  40                                  "foo", "bar", "xxxxxxxxxxxxxxxxx")
  41            == strlen(e));
  42
  43     ASSERT(buffer.size == strlen(e));
  44     ASSERT(MEMEQ(buffer.size, buffer.contents, e));
  45     nettle_buffer_clear(&buffer);
  46   }
  47   {
  48     const uint8_t e[] = "1:\0""1:a2:bc3:def4:ghij5:\x00\xDE\xAD\xBE\xEF";
  49
  50     nettle_buffer_init(&buffer);
  51     ASSERT(sexp_format(&buffer, "%i%i%i%i%i%i",
  52                        0, 0x61, 0x6263, 0x646566, 0x6768696a, 0xDEADBEEF)
  53            == LLENGTH(e));
  54
  55     ASSERT(buffer.size == LLENGTH(e));
  56     ASSERT(MEMEQ(buffer.size, buffer.contents, e));
  57     nettle_buffer_clear(&buffer);
  58   }
  59
  60   {
  61     const uint8_t e[] = "(3:foo(4:bar))";
  62
  63     nettle_buffer_init(&buffer);
  64     ASSERT(sexp_format(&buffer, "(%0s%l)",
  65                        "foo", 7, "(4:bar)")
  66            == strlen(e));
  67
  68     ASSERT(buffer.size == strlen(e));
  69     ASSERT(MEMEQ(buffer.size, buffer.contents, e));
  70     nettle_buffer_clear(&buffer);
  71   }
  72
  73   {
  74     const uint8_t e[] = "([1:t]3:foo3:bar[6:gazonk]3:baz1:q)";
  75
  76     nettle_buffer_init(&buffer);
  77     ASSERT(sexp_format(&buffer, "(%0t%0s%0s%0t%0s%0t%0s)",
  78                        "t", "foo", "bar", "gazonk", "baz", NULL, "q")
  79            == strlen(e));
  80
  81     ASSERT(MEMEQ(buffer.size, buffer.contents, e));
  82     nettle_buffer_clear(&buffer);
  83   }
  84
  85   /* Try literals */
  86   {
  87     const uint8_t e[] = "(3:foo(3:bar17:xxxxxxxxxxxxxxxxx))";
  88
  89     nettle_buffer_init(&buffer);
  90     ASSERT(sexp_format(&buffer, "(%0s(bar%0s))",
  91                        "foo", "xxxxxxxxxxxxxxxxx")
  92            == strlen(e));
  93
  94     ASSERT(sexp_format(NULL, "(%0s(bar %0s))",
  95                        "foo", "xxxxxxxxxxxxxxxxx")
  96            == strlen(e));
  97
  98     ASSERT(buffer.size == strlen(e));
  99     ASSERT(MEMEQ(buffer.size, buffer.contents, e));
 100     nettle_buffer_clear(&buffer);
 101   }
 102   {
 103     const uint8_t e[] = "(3:foo(3:bar17:xxxxxxxxxxxxxxxxx))";
 104
 105     nettle_buffer_init(&buffer);
 106     ASSERT(sexp_format(&buffer, "(%0s(bar xxxxxxxxxxxxxxxxx))",
 107                        "foo")
 108            == strlen(e));
 109
 110     ASSERT(sexp_format(NULL, "(%0s(bar xxxxxxxxxxxxxxxxx))",
 111                        "foo")
 112            == strlen(e));
 113
 114     ASSERT(buffer.size == strlen(e));
 115     ASSERT(MEMEQ(buffer.size, buffer.contents, e));
 116     nettle_buffer_clear(&buffer);
 117   }
 118
 119   /* Literal parenthesis */
 120   {
 121     const uint8_t e[] = ")3:foo(3:bar";
 122
 123     nettle_buffer_init(&buffer);
 124     ASSERT(sexp_format(&buffer, "%)foo%(%s", 3, "bar")
 125            == strlen(e));
 126
 127     ASSERT(sexp_format(NULL, "%)foo%(%s", 3, "bar")
 128            == strlen(e));
 129
 130     ASSERT(buffer.size == strlen(e));
 131     ASSERT(MEMEQ(buffer.size, buffer.contents, e));
 132     nettle_buffer_clear(&buffer);
 133   }
 134
 135 #if HAVE_LIBGMP
 136   {
 137     mpz_t x;
 138     mpz_t y;
 139     mpz_t z;
 140
 141     const uint8_t e[] =
 142       "(3:foo(3:bar1:\xff""11:abcdefghijk13:\0\x81""abcdefghijk))";
 143
 144     mpz_init_set_si(x, -1);
 145     nettle_mpz_init_set_str_256_u(y, 11, "abcdefghijk");
 146     nettle_mpz_init_set_str_256_u(z, 12, "\x81""abcdefghijk");
 147     nettle_buffer_init(&buffer);
 148
 149     ASSERT(sexp_format(&buffer, "(%0s(%0s%b%b%b))",
 150                      "foo", "bar", x, y, z)
 151            == LLENGTH(e));
 152
 153     ASSERT(sexp_format(NULL, "(%0s(%0s%b%b%b))",
 154                      "foo", "bar", x, y, z)
 155            == LLENGTH(e));
 156
 157     ASSERT(buffer.size == LLENGTH(e));
 158     ASSERT(MEMEQ(buffer.size, buffer.contents, e));
 159
 160     nettle_buffer_clear(&buffer);
 161     mpz_clear(x);
 162     mpz_clear(y);
 163     mpz_clear(z);
 164   }
 165 #endif /* HAVE_LIBGMP */
 166 }