Gitiles
Code Review Sign In
gerrit.osmocom.org / asn1c / b450ce9b92ef41a56dad8161cf620e0b8bcc2057 / . / tests / tests-skeletons / check-OER-NativeEnumerated.c
blob: fa9258ad3371fc00cda411a503360567d8c31ed6 [file] [log] [blame]
Lev Walkinf9f3e062017-08-27 20:34:58 -0700[diff] [blame]1#include <stdio.h>
2#include <assert.h>
3
4#include <asn_codecs.h>
5#include <NativeEnumerated.h>
6
7#define CHECK_DECODE(code, a, b, c) check_decode(__LINE__, code, a, b, c)
8#define CHECK_ROUNDTRIP(a) check_roundtrip(__LINE__, a);
9
10static void
11check_decode(int lineno, enum asn_dec_rval_code_e code, intmax_t control, const char *buf, size_t size) {
12 static char *code_s[] = { "RC_OK", "RC_WMORE", "RC_FAIL", "<error>" };
13
14 fprintf(stderr, "\n%d: OER decode (control %" PRIdMAX ")\n", lineno, control);
15
16 long value;
17 long *value_ptr = &value;
18 asn_dec_rval_t ret;
19
20 fprintf(stderr, "%d: buf[%zu]={%d, %d, ...}\n", lineno, size,
21 size <= 0 ? -1 : ((const uint8_t *)buf)[0],
22 size <= 1 ? -1 : ((const uint8_t *)buf)[1]);
23
24 ret = NativeEnumerated_decode_oer(NULL, &asn_DEF_NativeEnumerated, NULL,
25 (void **)&value_ptr, buf, size);
26 if(ret.code != RC_OK) {
27 /* Basic OER decode does not work */
28 fprintf(stderr, "%d: Failed oer_decode(ctl=%" PRIdMAX ", size=%zu)\n",
29 lineno, control, size);
30 if(ret.code == code) {
31 fprintf(stderr, " (That was expected)\n");
32 return;
33 } else {
34 fprintf(
35 stderr, " Unexpected return code %s (%d) expected %s\n",
36 code_s[(unsigned)ret.code <= RC_FAIL ? RC_FAIL : (RC_FAIL + 1)],
37 (int)ret.code, code_s[code]);
38 assert(ret.code == code);
39 }
40 } else {
41 intmax_t outcome = value;
42 if(outcome != control) {
43 /* Decoded value is wrong */
44 fprintf(stderr,
45 "%d: Decode result %" PRIdMAX " is not expected %" PRIdMAX
46 "\n",
47 lineno, outcome, control);
48 assert(outcome == control);
49 }
50 }
51
52 fprintf(stderr, "%d: Decode result %" PRIdMAX "\n", lineno, control);
53}
54
55static void
56dump_data(int lineno, const uint8_t *buf, size_t size) {
57 const uint8_t *p = buf;
58 const uint8_t *end = buf + size;
59
60 fprintf(stderr, "%d: Encoded: [", lineno);
61
62 for(; p < end; p++) {
63 fprintf(stderr, "\\x%02x", *(const unsigned char *)p);
64 }
65 fprintf(stderr, "] (%zu bytes)\n", size);
66}
67
68static void
69check_roundtrip(int lineno, intmax_t control) {
70 uint8_t tmpbuf[32];
71 size_t tmpbuf_size;
72
73 fprintf(stderr, "\n%d: OER round-trip value %" PRIdMAX "\n", lineno, control);
74
75 asn_enc_rval_t er;
76 asn_dec_rval_t ret;
77
78 long value_out = control;
79 long value_in = -42;
80 long *value_in_ptr = &value_in;
81
82 er = oer_encode_to_buffer(&asn_DEF_NativeEnumerated, NULL,
83 &value_out, tmpbuf, sizeof(tmpbuf));
84 if(er.encoded == -1) {
85 fprintf(stderr, "%d: OER encode failed for %s\n", lineno,
86 er.failed_type ? er.failed_type->name : "<none>");
87 assert(er.encoded != -1);
88 }
89 tmpbuf_size = er.encoded;
90
91 dump_data(lineno, tmpbuf, tmpbuf_size);
92
93 ret = asn_DEF_NativeEnumerated.op->oer_decoder(0, &asn_DEF_NativeEnumerated,
94 NULL, (void **)&value_in_ptr,
95 tmpbuf, tmpbuf_size);
96 if(ret.code != RC_OK) {
97 /* Basic OER decode does not work */
98 fprintf(stderr, "%d: Failed oer_decode(value=%" PRIdMAX ", size=%zu)\n",
99 lineno, control, tmpbuf_size);
100 assert(ret.code == 0);
101 } else {
102 intmax_t outcome = value_in;
103 if(outcome != control) {
104 /* Decoded value is wrong */
105 fprintf(stderr,
106 "%d: Decode result %" PRIdMAX " is not expected %" PRIdMAX
107 "\n",
108 lineno, outcome, control);
109 assert(outcome == control);
110 }
111 }
112
113 fprintf(stderr, "%d: Decode result %" PRIdMAX "\n", lineno, control);
114}
115
116int
117main() {
118 CHECK_DECODE(RC_WMORE, 0, "", 0);
119 CHECK_DECODE(RC_OK, 0, "\x00", 1);
120 CHECK_DECODE(RC_FAIL, 0, "\x00", 1);
121 CHECK_DECODE(RC_WMORE, 0, "", 0);
122 CHECK_DECODE(RC_WMORE, 0, "", 0);
123 CHECK_DECODE(RC_OK, 0, "\x00", 1);
124 CHECK_DECODE(RC_OK, 0, "\x00", 1);
125
126 CHECK_DECODE(RC_OK, 0, "\x00", 1);
127 CHECK_DECODE(RC_OK, 1, "\x01", 1);
128 CHECK_DECODE(RC_FAIL, 0, "\xff", 1);
129 CHECK_DECODE(RC_FAIL, 0, "\x89", 1);
130 CHECK_DECODE(RC_WMORE, 0, "\x84", 1);
131 CHECK_DECODE(RC_WMORE, 0, "\x84\x00", 3);
132 CHECK_DECODE(RC_WMORE, 0, "\x84\x00\x00", 3);
133 CHECK_DECODE(RC_WMORE, 0, "\x84\x00\x00\x00", 4);
134 CHECK_DECODE(RC_OK, 0, "\x84\x00\x00\x00\x00", 5);
135 CHECK_DECODE(RC_OK, 1, "\x84\x00\x00\x00\x01", 5);
136 CHECK_DECODE(RC_OK, 127, "\x7f", 1);
137 CHECK_DECODE(RC_OK, 127, "\x81\x7f", 2);
138 CHECK_DECODE(RC_OK, 255, "\x82\x00\xff", 3);
139 CHECK_DECODE(RC_OK, -1, "\x81\xff", 2);
140 CHECK_DECODE(RC_OK, -1, "\x82\xff\xff", 3);
141
142 CHECK_DECODE(RC_OK, 1, "\x01\x00", 2);
143 CHECK_DECODE(RC_OK, 1, "\x01\x01", 2);
144 CHECK_DECODE(RC_OK, -1, "\x81\xff", 2);
145 CHECK_DECODE(RC_WMORE, -1, "\x82\x00\xff", 2);
146
147 CHECK_ROUNDTRIP(0);
148 CHECK_ROUNDTRIP(1);
149 CHECK_ROUNDTRIP(-1);
150 CHECK_ROUNDTRIP(-127);
151 CHECK_ROUNDTRIP(-128);
152 CHECK_ROUNDTRIP(-129);
153 CHECK_ROUNDTRIP(126);
154 CHECK_ROUNDTRIP(127);
155 CHECK_ROUNDTRIP(128);
156 CHECK_ROUNDTRIP(-65000);
157 CHECK_ROUNDTRIP(65000);
158 CHECK_ROUNDTRIP(65535);
159 CHECK_ROUNDTRIP(-65535);
160 CHECK_ROUNDTRIP(-65536);
161 CHECK_ROUNDTRIP(65536);
162 CHECK_ROUNDTRIP(32000);
163
164 for(size_t i = 0; i < 7 ; i++) {
165 intmax_t value = (intmax_t)1 << i;
166 CHECK_ROUNDTRIP(value);
167 value = -value;
168 CHECK_ROUNDTRIP(value);
169 }
170
171 for(size_t i = 0; i < 16 ; i++) {
172 intmax_t value = (intmax_t)1 << i;
173 CHECK_ROUNDTRIP(value);
174 value = -value;
175 CHECK_ROUNDTRIP(value);
176 }
177
178 for(size_t i = 0; i < 32 ; i++) {
179 intmax_t value = (intmax_t)1 << i;
180 CHECK_ROUNDTRIP(value);
181 value = -value;
182 CHECK_ROUNDTRIP(value);
183 }
184
Lev Walkina9e63372017-09-17 23:24:56 -0700[diff] [blame]185 for(size_t i = 0; i < 8 * sizeof(intmax_t) - 1; i++) {
Lev Walkinf9f3e062017-08-27 20:34:58 -0700[diff] [blame]186 intmax_t value = (intmax_t)1 << i;
187 CHECK_ROUNDTRIP(value);
188 value = -value;
189 CHECK_ROUNDTRIP(value);
190 }
191
192}