tests/tests-skeletons/check-OCTET_STRING.c

   1 #include <stdio.h>
   2 #include <assert.h>
   3 #include <time.h>
   4 #include <sys/time.h>
   5
   6 #include <OCTET_STRING.h>
   7 #include <BIT_STRING.h>
   8
   9 enum encoding_type { HEX, BINARY, UTF8 };
  10
  11 #define check(t, tag, buf, verify)  check_impl(__LINE__, t, tag, buf, verify)
  12
  13 static void
  14 check_impl(int lineno, enum encoding_type type, char *tagname, char *xmlbuf, char *verify) {
  15         size_t xmllen = strlen(xmlbuf);
  16         size_t verlen = verify ? strlen(verify) : 0;
  17         asn_TYPE_descriptor_t *td = &asn_DEF_OCTET_STRING;
  18         OCTET_STRING_t *st = 0;
  19         OCTET_STRING_t **stp = &st;
  20         asn_dec_rval_t rc;
  21         xer_type_decoder_f *decoder = 0;
  22
  23         switch(type) {
  24         case HEX:
  25                 decoder = OCTET_STRING_decode_xer_hex;
  26                 break;
  27         case BINARY:
  28                 td = &asn_DEF_BIT_STRING;
  29                 decoder = OCTET_STRING_decode_xer_binary;
  30                 break;
  31         case UTF8:
  32                 decoder = OCTET_STRING_decode_xer_utf8;
  33                 break;
  34         }
  35
  36         rc = decoder(0, td, (void **)stp, tagname, xmlbuf, xmllen);
  37         printf("%03d: [%s] => [%s]:%zu vs [%s]:%zu, code %d\n",
  38                 lineno, xmlbuf,
  39                 st ? (const char *)st->buf : "", st ? st->size : 0,
  40                 verify ? verify : "", verlen, rc.code);
  41
  42         if(verify) {
  43                 assert(rc.code == RC_OK);
  44                 assert(st);
  45                 assert(st->buf);
  46                 assert(st->size == verlen);
  47                 assert(!memcmp(st->buf, verify, verlen));
  48         } else {
  49                 assert(rc.code != RC_OK);
  50         }
  51
  52         ASN_STRUCT_FREE(*td, st);
  53 }
  54
  55 static char buf[1024];
  56
  57 static int
  58 write_buf(const void *buffer, size_t size, void *key) {
  59         size_t *off = key;
  60         assert(*off + size < sizeof(buf));
  61         memcpy(buf + *off, buffer, size);
  62         *off += size;
  63         return 0;
  64 }
  65
  66 static void
  67 encode(char *orig, char *encoded) {
  68         OCTET_STRING_t os;
  69         size_t written = 0;
  70         asn_enc_rval_t er;
  71
  72         memset(&os, 0, sizeof(os));
  73
  74         OCTET_STRING_fromString(&os, orig);
  75
  76         er = OCTET_STRING_encode_xer_utf8(&asn_DEF_OCTET_STRING, &os,
  77                         0, 0, write_buf, &written);
  78         assert(er.encoded >= 0);
  79         buf[er.encoded] = '\0';
  80         printf("Orig: [%s], encoded: [%s], check [%s]\n",
  81                 orig, buf, encoded);
  82         assert(strcmp(buf, encoded) == 0);
  83         ASN_STRUCT_RESET(asn_DEF_OCTET_STRING, &os);
  84 }
  85
  86 int
  87 main() {
  88
  89         check(HEX, 0, "<OCTET_STRING>41424</OCTET_STRING>",
  90                 "AB@");
  91
  92         check(HEX, 0, "<!--comment--><OCTET_STRING>\n"
  93                 "<!--comment-->41424</OCTET_STRING>",
  94                 "AB@");
  95
  96         check(HEX, 0, "<OCTET_STRING blah blah> 4 1 4 2 4 5 44 </OCTET_STRING>",
  97                 "ABED");
  98
  99         /* Some hard cases */
 100         check(HEX, "z", "<z><!-- < -->40</z>", "@");
 101         check(HEX, "z", "<z><!-- <-->40</z>", "@");
 102         check(HEX, "z", "<z><!-- -->>40</z>", 0);
 103         check(HEX, "z", "<z><!-- <some <sometag>-->40</z>", "@");
 104         check(HEX, "z", "<z><!-- <some <sometag-->>40</z>", 0);
 105
 106         check(HEX, "z", "ignored<z>40</z>stuff", "@");
 107
 108         check(HEX, "tag", "<tag>4</tag>", "@");
 109         check(HEX, "a-z", "<a-z>7 375 73 6c6 9<!--/-->6 b</a-z>", "suslik");
 110
 111         /* This one has a comment in a not-yet-supported place */
 112         /* check(HEX, "a-z", "<a-z>73 75 73 6c 6<!--/-->9 6b</a-z>",
 113                 "suslik"); */
 114
 115         check(BINARY, "tag", "<tag/>", "");
 116         check(BINARY, "tag", "<tag>blah</tag>", 0);
 117         check(BINARY, "tag", "<tag>01000001</tag>", "A");
 118         check(BINARY, "tag", "<tag>01000<!--blah--> 00 101 00001</tag>", "AB");
 119
 120         check(UTF8, 0, "<OCTET_STRING>one, two, three</OCTET_STRING>",
 121                 "one, two, three");
 122
 123         check(UTF8, "z", "<z></z>", "");
 124         check(UTF8, "z", "<z z z>&lt;&amp;&gt;</z z z>", "<&>");
 125         check(UTF8, "z", "<z z z>a&lt;b&amp;c&gt;d</z z z>", "a<b&c>d");
 126         check(UTF8, "z", "<z z z>a&lt</z z z>", "a&lt");
 127         check(UTF8, "z", "<z z z>a&sdfsdfsdf;b</z z z>", "a&sdfsdfsdf;b");
 128         check(UTF8, "z", "<z z z>a&#x20;b</z z z>", "a b");
 129         check(UTF8, "z", "<z z z>a&#32;b</z z z>", "a b");
 130         check(UTF8, "z", "<z>a&#32323;b</z>", "a\347\271\203b");
 131         check(UTF8, "z", "<z>a&#x4fc4;|</z>", "a\xe4\xbf\x84|");
 132     /* Last unicode point */
 133         check(UTF8, "z", "<z>a&#x10ffff;|</z>", "a\xf4\x8f\xbf\xbf|");
 134         check(UTF8, "z", "<z>a&#1114111;|</z>", "a\xf4\x8f\xbf\xbf|");
 135     /* One past the last unicode point */
 136         check(UTF8, "z", "<z>a&#x110000;|</z>", "a&#x110000;|");
 137         check(UTF8, "z", "<z>a&#1114112;|</z>", "a&#1114112;|");
 138         check(UTF8, "z", "<z>a&#3000000000;b</z>", "a&#3000000000;b");
 139         check(UTF8, "z", "<z>a&#5000000000;b</z>", "a&#5000000000;b");
 140         check(UTF8, "z", "<z>a&#300</z>", "a&#300");
 141         check(UTF8, "z", "<z>a&#-300;</z>", "a&#-300;");
 142         check(UTF8, "z", "<z>a<ff/>b</z>", "a\014b");
 143         check(UTF8, "z", "<z>a<soh/>b</z>", "a\001b");
 144         check(UTF8, "z", "<z>a<bel/></z>", "a\007");
 145
 146         encode("", "");
 147         encode("a", "a");
 148         encode("a\nb", "a\nb");
 149         encode("a\bc", "a<bs/>c");
 150         encode("ab\01c\ndef\r\n", "ab<soh/>c\ndef\r\n");
 151
 152         return 0;
 153 }
 154