Branch data Line data Source code
1 : : // Copyright 2021-2026 David Robillard <d@drobilla.net>
2 : : // SPDX-License-Identifier: ISC
3 : :
4 : : #undef NDEBUG
5 : :
6 : : #include "decimal_test_utils.h"
7 : : #include "double_test_utils.h"
8 : : #include "float_test_utils.h"
9 : : #include "integer_test_utils.h"
10 : : #include "write_test_utils.h"
11 : :
12 : : #include <exess/exess.h>
13 : :
14 : : #include <assert.h>
15 : : #include <math.h>
16 : : #include <stdbool.h>
17 : : #include <stdint.h>
18 : : #include <string.h>
19 : :
20 : : #define VALUE_SIZE 28U
21 : : #define STRING_SIZE 20U
22 : :
23 : : static const ExessDuration duration = {14,
24 : : (3 * 24 * 60 * 60) + (4 * 60 * 60) +
25 : : (5 * 60) + 6,
26 : : 0};
27 : :
28 : : static const ExessDateTime datetime =
29 : : {2001, 2, 3, EXESS_TIMEZONE_LOCAL, 4, 5, 6, 0};
30 : :
31 : : static const ExessTime time = {EXESS_TIMEZONE_UTC, 1, 2, 3, 0};
32 : : static const ExessDate date = {2001, 2, 3, EXESS_TIMEZONE_UTC};
33 : :
34 : : static void
35 : 75 : check_read(void* value,
36 : : const ExessDatatype datatype,
37 : : const char* const string,
38 : : const ExessStatus expected_status,
39 : : const size_t expected_read_count)
40 : : {
41 : : const ExessVariableResult r =
42 : 75 : exess_read_value(datatype, string, EXESS_MAX_FIXED_SIZE, value);
43 : :
44 [ - + ]: 75 : assert(r.status == expected_status);
45 [ - + ]: 75 : assert(r.read_count == expected_read_count);
46 [ + + ]: 75 : if (!r.status) {
47 [ + + - + ]: 34 : assert(!exess_value_sizes[datatype] ||
48 : : r.write_count == exess_value_sizes[datatype]);
49 : :
50 : : } else {
51 [ - + ]: 41 : assert(!r.write_count);
52 : : }
53 : 75 : }
54 : :
55 : : static void
56 : 5 : check_decimal_value(const void* const decimal, const double number)
57 : : {
58 : 5 : EXESS_ALIGN uint8_t check[VALUE_SIZE] = {0};
59 : 5 : const size_t size = set_decimal_value(sizeof(check), check, number);
60 [ - + ]: 5 : assert(!memcmp(decimal, check, size));
61 : 5 : }
62 : :
63 : : static void
64 : 1 : check_integer_value(const void* const integer, const int64_t number)
65 : : {
66 : 1 : EXESS_ALIGN uint8_t check[VALUE_SIZE] = {0};
67 : 1 : const size_t size = set_integer_value(sizeof(check), check, number);
68 [ - + ]: 1 : assert(!memcmp(integer, check, size));
69 : 1 : }
70 : :
71 : : static void
72 : 1 : test_read_value(void)
73 : : {
74 : : {
75 : 1 : int64_t a_long = 0;
76 : : const ExessVariableResult bad =
77 : 1 : exess_read_value(EXESS_LONG, "1", 7, &a_long);
78 [ - + ]: 1 : assert(bad.status == EXESS_NO_SPACE);
79 : : }
80 : : {
81 : 1 : bool a_bool = false;
82 : 1 : check_read(&a_bool, EXESS_BOOLEAN, "x", EXESS_EXPECTED_BOOLEAN, 0);
83 : 1 : check_read(&a_bool, EXESS_BOOLEAN, "true", EXESS_SUCCESS, 4);
84 [ - + ]: 1 : assert(a_bool);
85 : : }
86 : : {
87 : 1 : EXESS_ALIGN uint8_t a_decimal[VALUE_SIZE] = {0};
88 : 1 : check_read(a_decimal, EXESS_DECIMAL, "1.2", EXESS_SUCCESS, 3);
89 : 1 : check_decimal_value(a_decimal, 1.2);
90 : : }
91 : : {
92 : 1 : double a_double = (double)NAN;
93 : 1 : check_read(&a_double, EXESS_DOUBLE, "3.4", EXESS_SUCCESS, 3);
94 [ - + ]: 1 : assert(double_matches(a_double, 3.4));
95 : : }
96 : : {
97 : 1 : float a_float = NAN;
98 : 1 : check_read(&a_float, EXESS_FLOAT, "x", EXESS_EXPECTED_DIGIT, 0);
99 : :
100 : 1 : check_read(&a_float, EXESS_FLOAT, "5.6", EXESS_SUCCESS, 3);
101 [ - + ]: 1 : assert(float_matches(a_float, 5.6f));
102 : : }
103 : : {
104 : 1 : EXESS_ALIGN uint8_t a_decimal[VALUE_SIZE] = {0};
105 : :
106 : 1 : check_read(a_decimal, EXESS_NOTHING, "42", EXESS_UNSUPPORTED, 0);
107 : :
108 : 1 : check_read(a_decimal, EXESS_INTEGER, "x", EXESS_EXPECTED_DIGIT, 0);
109 : 1 : check_read(a_decimal, EXESS_INTEGER, "7", EXESS_SUCCESS, 1);
110 : 1 : check_decimal_value(a_decimal, 7.0);
111 : :
112 : 1 : check_read(
113 : : a_decimal, EXESS_NON_POSITIVE_INTEGER, "x", EXESS_EXPECTED_DIGIT, 0);
114 : 1 : check_read(
115 : : a_decimal, EXESS_NON_POSITIVE_INTEGER, "1", EXESS_OUT_OF_RANGE, 1);
116 : 1 : check_read(a_decimal, EXESS_NON_POSITIVE_INTEGER, "-8", EXESS_SUCCESS, 2);
117 : 1 : check_decimal_value(a_decimal, -8.0);
118 : :
119 : 1 : check_read(a_decimal, EXESS_NEGATIVE_INTEGER, "x", EXESS_EXPECTED_DIGIT, 0);
120 : 1 : check_read(a_decimal, EXESS_NEGATIVE_INTEGER, "1", EXESS_OUT_OF_RANGE, 1);
121 : 1 : check_read(a_decimal, EXESS_NEGATIVE_INTEGER, "-9", EXESS_SUCCESS, 2);
122 : 1 : check_decimal_value(a_decimal, -9.0);
123 : :
124 : 1 : check_read(
125 : : a_decimal, EXESS_NON_NEGATIVE_INTEGER, "x", EXESS_EXPECTED_DIGIT, 0);
126 : 1 : check_read(
127 : : a_decimal, EXESS_NON_NEGATIVE_INTEGER, "-1", EXESS_OUT_OF_RANGE, 2);
128 : 1 : check_read(a_decimal, EXESS_NON_NEGATIVE_INTEGER, "-0", EXESS_SUCCESS, 2);
129 : 1 : check_read(a_decimal, EXESS_NON_NEGATIVE_INTEGER, "0", EXESS_SUCCESS, 1);
130 : 1 : check_read(a_decimal, EXESS_NON_NEGATIVE_INTEGER, "+0", EXESS_SUCCESS, 2);
131 : 1 : check_read(a_decimal, EXESS_NON_NEGATIVE_INTEGER, "43", EXESS_SUCCESS, 2);
132 : 1 : check_decimal_value(a_decimal, 43.0);
133 : : }
134 : : {
135 : 1 : int64_t a_long = 0;
136 : 1 : check_read(&a_long, EXESS_LONG, "10", EXESS_SUCCESS, 2);
137 [ - + ]: 1 : assert(a_long == 10);
138 : : }
139 : : {
140 : 1 : int32_t a_int = 0;
141 : 1 : check_read(&a_int, EXESS_INT, "x", EXESS_EXPECTED_DIGIT, 0);
142 : 1 : check_read(&a_int, EXESS_INT, "11", EXESS_SUCCESS, 2);
143 [ - + ]: 1 : assert(a_int == 11);
144 : : }
145 : : {
146 : 1 : int16_t a_short = 0;
147 : 1 : check_read(&a_short, EXESS_SHORT, "x", EXESS_EXPECTED_DIGIT, 0);
148 : 1 : check_read(&a_short, EXESS_SHORT, "12", EXESS_SUCCESS, 2);
149 [ - + ]: 1 : assert(a_short == 12);
150 : : }
151 : : {
152 : 1 : int8_t a_byte = 0;
153 : 1 : check_read(&a_byte, EXESS_BYTE, "x", EXESS_EXPECTED_DIGIT, 0);
154 : 1 : check_read(&a_byte, EXESS_BYTE, "13", EXESS_SUCCESS, 2);
155 [ - + ]: 1 : assert(a_byte == 13);
156 : : }
157 : : {
158 : 1 : uint64_t a_ulong = 0U;
159 : 1 : check_read(&a_ulong, EXESS_ULONG, "x", EXESS_EXPECTED_DIGIT, 0);
160 : 1 : check_read(&a_ulong, EXESS_ULONG, "14", EXESS_SUCCESS, 2);
161 [ - + ]: 1 : assert(a_ulong == 14U);
162 : : }
163 : : {
164 : 1 : uint32_t a_uint = 0U;
165 : 1 : check_read(&a_uint, EXESS_UINT, "x", EXESS_EXPECTED_DIGIT, 0);
166 : 1 : check_read(&a_uint, EXESS_UINT, "15", EXESS_SUCCESS, 2);
167 [ - + ]: 1 : assert(a_uint == 15U);
168 : : }
169 : : {
170 : 1 : uint16_t a_ushort = 0U;
171 : 1 : check_read(&a_ushort, EXESS_USHORT, "x", EXESS_EXPECTED_DIGIT, 0);
172 : 1 : check_read(&a_ushort, EXESS_USHORT, "16", EXESS_SUCCESS, 2);
173 [ - + ]: 1 : assert(a_ushort == 16U);
174 : : }
175 : : {
176 : 1 : uint8_t a_ubyte = 0U;
177 : 1 : check_read(&a_ubyte, EXESS_UBYTE, "x", EXESS_EXPECTED_DIGIT, 0);
178 : 1 : check_read(&a_ubyte, EXESS_UBYTE, "17", EXESS_SUCCESS, 2);
179 [ - + ]: 1 : assert(a_ubyte == 17U);
180 : : }
181 : : {
182 : 1 : EXESS_ALIGN uint8_t a_integer[VALUE_SIZE] = {0};
183 : 1 : check_read(a_integer, EXESS_POSITIVE_INTEGER, "E", EXESS_EXPECTED_DIGIT, 0);
184 : 1 : check_read(a_integer, EXESS_POSITIVE_INTEGER, "-1", EXESS_OUT_OF_RANGE, 2);
185 : 1 : check_read(a_integer, EXESS_POSITIVE_INTEGER, "-0", EXESS_OUT_OF_RANGE, 2);
186 : 1 : check_read(a_integer, EXESS_POSITIVE_INTEGER, "0", EXESS_OUT_OF_RANGE, 1);
187 : 1 : check_read(a_integer, EXESS_POSITIVE_INTEGER, "+0", EXESS_OUT_OF_RANGE, 2);
188 : 1 : check_read(a_integer, EXESS_POSITIVE_INTEGER, "18", EXESS_SUCCESS, 2);
189 : 1 : check_integer_value(a_integer, 18);
190 : : }
191 : : {
192 : 1 : ExessDuration a_duration = {1, 2, 3};
193 : 1 : check_read(&a_duration, EXESS_DURATION, "x", EXESS_EXPECTED_DURATION, 0);
194 : :
195 : 1 : check_read(
196 : : &a_duration, EXESS_DURATION, "P1MT2.000000003S", EXESS_SUCCESS, 16);
197 : :
198 [ - + ]: 1 : assert(a_duration.months == 1);
199 [ - + ]: 1 : assert(a_duration.seconds == 2);
200 [ - + ]: 1 : assert(a_duration.nanoseconds == 3);
201 : :
202 : 1 : check_read(
203 : : &a_duration, EXESS_YEAR_MONTH_DURATION, "x", EXESS_EXPECTED_DURATION, 0);
204 : 1 : check_read(
205 : : &a_duration, EXESS_DAY_TIME_DURATION, "x", EXESS_EXPECTED_DURATION, 0);
206 : :
207 : 1 : check_read(&a_duration, EXESS_YEAR_MONTH_DURATION, "P1M", EXESS_SUCCESS, 3);
208 : 1 : check_read(
209 : : &a_duration, EXESS_DAY_TIME_DURATION, "PT2.3S", EXESS_SUCCESS, 6);
210 : :
211 : 1 : check_read(
212 : : &a_duration, EXESS_YEAR_MONTH_DURATION, "PT0.1S", EXESS_BAD_VALUE, 6);
213 : 1 : check_read(
214 : : &a_duration, EXESS_YEAR_MONTH_DURATION, "PT1.0S", EXESS_BAD_VALUE, 6);
215 : 1 : check_read(
216 : : &a_duration, EXESS_YEAR_MONTH_DURATION, "PT1.2S", EXESS_BAD_VALUE, 6);
217 : 1 : check_read(&a_duration, EXESS_DAY_TIME_DURATION, "P1M", EXESS_BAD_VALUE, 3);
218 : : }
219 : : {
220 : 1 : ExessDateTime a_datetime = datetime;
221 : 1 : check_read(&a_datetime, EXESS_DATE_TIME, "x", EXESS_EXPECTED_DIGIT, 0);
222 : :
223 : 1 : check_read(&a_datetime,
224 : : EXESS_DATE_TIME,
225 : : "2001-01-02T12:15:01.25",
226 : : EXESS_SUCCESS,
227 : : 22);
228 : :
229 [ - + ]: 1 : assert(a_datetime.year == 2001);
230 [ - + ]: 1 : assert(a_datetime.month == 1);
231 [ - + ]: 1 : assert(a_datetime.day == 2);
232 [ - + ]: 1 : assert(a_datetime.hour == 12);
233 [ - + ]: 1 : assert(a_datetime.minute == 15);
234 [ - + ]: 1 : assert(a_datetime.second == 1);
235 [ - + ]: 1 : assert(a_datetime.nanosecond == 250000000);
236 : :
237 : 1 : check_read(
238 : : &a_datetime, EXESS_DATE_TIME_STAMP, "x", EXESS_EXPECTED_DIGIT, 0);
239 : :
240 : 1 : check_read(&a_datetime,
241 : : EXESS_DATE_TIME_STAMP,
242 : : "2001-01-02T12:15:16Z",
243 : : EXESS_SUCCESS,
244 : : 20);
245 : :
246 : 1 : check_read(&a_datetime,
247 : : EXESS_DATE_TIME_STAMP,
248 : : "2001-01-02T12:15:16",
249 : : EXESS_BAD_VALUE,
250 : : 19);
251 : : }
252 : : {
253 : 1 : ExessDate a_date = date;
254 : 1 : check_read(&a_date, EXESS_DATE, "x", EXESS_EXPECTED_DIGIT, 0);
255 : 1 : check_read(&a_date, EXESS_DATE, "2001-01-02", EXESS_SUCCESS, 10);
256 [ - + ]: 1 : assert(a_date.year == 2001);
257 [ - + ]: 1 : assert(a_date.month == 1);
258 [ - + ]: 1 : assert(a_date.day == 2);
259 : : }
260 : : {
261 : 1 : ExessTime a_time = time;
262 : 1 : check_read(&a_time, EXESS_TIME, "x", EXESS_EXPECTED_DIGIT, 0);
263 : 1 : check_read(&a_time, EXESS_TIME, "12:15:01.25", EXESS_SUCCESS, 11);
264 [ - + ]: 1 : assert(a_time.hour == 12);
265 [ - + ]: 1 : assert(a_time.minute == 15);
266 [ - + ]: 1 : assert(a_time.second == 1);
267 [ - + ]: 1 : assert(a_time.nanosecond == 250000000);
268 : : }
269 : : {
270 : 1 : ExessYearMonth a_year_month = {date.year, date.month, date.zone};
271 : 1 : check_read(&a_year_month, EXESS_YEAR_MONTH, "x", EXESS_EXPECTED_DIGIT, 0);
272 : 1 : check_read(&a_year_month, EXESS_YEAR_MONTH, "2001-01", EXESS_SUCCESS, 7);
273 [ - + ]: 1 : assert(a_year_month.year == 2001);
274 [ - + ]: 1 : assert(a_year_month.month == 1);
275 : : }
276 : : {
277 : 1 : ExessYear a_year = {date.year, date.zone};
278 : 1 : check_read(&a_year, EXESS_YEAR, "x", EXESS_EXPECTED_DIGIT, 0);
279 : 1 : check_read(&a_year, EXESS_YEAR, "2001", EXESS_SUCCESS, 4);
280 [ - + ]: 1 : assert(a_year.year == 2001);
281 : : }
282 : : {
283 : 1 : ExessMonthDay a_month_day = {date.month, date.day, date.zone};
284 : 1 : check_read(&a_month_day, EXESS_MONTH_DAY, "x", EXESS_EXPECTED_DASH, 0);
285 : 1 : check_read(&a_month_day, EXESS_MONTH_DAY, "--01-02", EXESS_SUCCESS, 7);
286 [ - + ]: 1 : assert(a_month_day.month == 1);
287 [ - + ]: 1 : assert(a_month_day.day == 2);
288 : : }
289 : : {
290 : 1 : ExessDay a_day = {date.day, date.zone};
291 : 1 : check_read(&a_day, EXESS_DAY, "x", EXESS_EXPECTED_DASH, 0);
292 : 1 : check_read(&a_day, EXESS_DAY, "---02", EXESS_SUCCESS, 5);
293 [ - + ]: 1 : assert(a_day.day == 2);
294 : : }
295 : : {
296 : 1 : ExessMonth a_month = {date.month, date.zone};
297 : 1 : check_read(&a_month, EXESS_MONTH, "x", EXESS_EXPECTED_DASH, 0);
298 : 1 : check_read(&a_month, EXESS_MONTH, "--01", EXESS_SUCCESS, 4);
299 [ - + ]: 1 : assert(a_month.month == 1);
300 : : }
301 : : {
302 : 1 : char a_blob[] = {1, 2, 3};
303 : 1 : check_read(a_blob, EXESS_HEX, "!", EXESS_EXPECTED_HEX, 0);
304 : 1 : check_read(a_blob, EXESS_HEX, "666F6F", EXESS_SUCCESS, 6);
305 [ - + ]: 1 : assert(!strncmp(a_blob, "foo", sizeof(a_blob)));
306 : : }
307 : : {
308 : 1 : char a_blob[] = {1, 2, 3};
309 : 1 : check_read(a_blob, EXESS_BASE64, "!", EXESS_EXPECTED_BASE64, 0);
310 : 1 : check_read(a_blob, EXESS_BASE64, "Zm9v", EXESS_SUCCESS, 4);
311 [ - + ]: 1 : assert(!strncmp(a_blob, "foo", sizeof(a_blob)));
312 : : }
313 : 1 : }
314 : :
315 : : static void
316 : 28 : check_write(const ExessDatatype datatype,
317 : : const size_t value_size,
318 : : const void* value,
319 : : const size_t buf_size,
320 : : const char* const expected_string)
321 : : {
322 : 28 : char buf[STRING_SIZE] = {42};
323 : :
324 [ - + ]: 28 : assert(buf_size <= sizeof(buf));
325 : 28 : init_out_buf(sizeof(buf), buf);
326 : :
327 : : const ExessResult r =
328 : 28 : exess_write_value(datatype, value_size, value, buf_size, buf);
329 : :
330 [ - + ]: 28 : assert(!r.status);
331 [ - + ]: 28 : assert(r.count + 1U == buf_size);
332 [ - + ]: 28 : assert(r.count == strlen(buf));
333 [ - + ]: 28 : assert(!strcmp(buf, expected_string));
334 : :
335 [ + + ]: 174 : for (size_t space = 0U; space < r.count; ++space) {
336 : 146 : buf[0] = 1;
337 : :
338 : : const ExessResult s =
339 : 146 : exess_write_value(datatype, value_size, value, space, buf);
340 : :
341 [ - + ]: 146 : assert(s.status == EXESS_NO_SPACE);
342 [ - + ]: 146 : assert(s.count == r.count);
343 [ - + ]: 146 : assert(buf[0] == (space ? 0 : 1));
344 : : }
345 : 28 : }
346 : :
347 : : static void
348 : 1 : test_write_value(void)
349 : : {
350 : 1 : uint8_t a_blob[] = {'f', 'o', 'o'};
351 : :
352 : 1 : EXESS_ALIGN uint8_t a_decimal[VALUE_SIZE] = {0};
353 : 1 : set_decimal_value(sizeof(a_decimal), a_decimal, 1.2);
354 : :
355 : 1 : const bool a_bool = true;
356 : 1 : const double a_double = 3.4;
357 : 1 : const float a_float = 5.6f;
358 : 1 : const int64_t a_long = 7;
359 : 1 : const int32_t a_int = 8;
360 : 1 : const int16_t a_short = 9;
361 : 1 : const int8_t a_byte = 10;
362 : 1 : const uint64_t a_ulong = 11U;
363 : 1 : const uint32_t a_uint = 12U;
364 : 1 : const uint16_t a_ushort = 13U;
365 : 1 : const uint8_t a_ubyte = 14U;
366 : 1 : const ExessDuration a_duration = duration;
367 : 1 : const ExessDateTime a_datetime = datetime;
368 : 1 : const ExessTime a_time = time;
369 : 1 : const ExessDate a_date = date;
370 : :
371 : : {
372 : 1 : char buf = '\0';
373 [ - + ]: 1 : assert(exess_write_value(EXESS_NOTHING, 1, &buf, 1, &buf).status ==
374 : : EXESS_BAD_VALUE);
375 : : }
376 : :
377 : 1 : check_write(EXESS_BOOLEAN, sizeof(a_bool), &a_bool, 5, "true");
378 : 1 : check_write(EXESS_DECIMAL, sizeof(a_decimal), &a_decimal, 4, "1.2");
379 : 1 : check_write(EXESS_DOUBLE, sizeof(a_double), &a_double, 6, "3.4E0");
380 : 1 : check_write(EXESS_FLOAT, sizeof(a_float), &a_float, 12, "5.5999999E0");
381 : 1 : check_write(EXESS_LONG, sizeof(a_long), &a_long, 2, "7");
382 : 1 : check_write(EXESS_INT, sizeof(a_int), &a_int, 2, "8");
383 : 1 : check_write(EXESS_SHORT, sizeof(a_short), &a_short, 2, "9");
384 : 1 : check_write(EXESS_BYTE, sizeof(a_byte), &a_byte, 3, "10");
385 : 1 : check_write(EXESS_ULONG, sizeof(a_ulong), &a_ulong, 3, "11");
386 : 1 : check_write(EXESS_UINT, sizeof(a_uint), &a_uint, 3, "12");
387 : 1 : check_write(EXESS_USHORT, sizeof(a_ushort), &a_ushort, 3, "13");
388 : 1 : check_write(EXESS_UBYTE, sizeof(a_ubyte), &a_ubyte, 3, "14");
389 : :
390 : : {
391 : 1 : EXESS_ALIGN uint8_t a_integer[VALUE_SIZE] = {0};
392 : :
393 : 1 : set_integer_value(sizeof(a_integer), a_integer, -15);
394 : 1 : check_write(EXESS_INTEGER, sizeof(a_integer), &a_integer, 4, "-15");
395 : 1 : check_write(
396 : : EXESS_NON_POSITIVE_INTEGER, sizeof(a_integer), &a_integer, 4, "-15");
397 : 1 : check_write(
398 : : EXESS_NEGATIVE_INTEGER, sizeof(a_integer), &a_integer, 4, "-15");
399 : :
400 : 1 : set_integer_value(sizeof(a_integer), a_integer, -16);
401 : 1 : check_write(
402 : : EXESS_NON_NEGATIVE_INTEGER, sizeof(a_integer), &a_integer, 4, "-16");
403 : 1 : check_write(
404 : : EXESS_POSITIVE_INTEGER, sizeof(a_integer), &a_integer, 4, "-16");
405 : : }
406 : :
407 : 1 : check_write(
408 : : EXESS_DURATION, sizeof(a_duration), &a_duration, 15, "P1Y2M3DT4H5M6S");
409 : :
410 : 1 : check_write(EXESS_DATE_TIME,
411 : : sizeof(a_datetime),
412 : : &a_datetime,
413 : : 20,
414 : : "2001-02-03T04:05:06");
415 : :
416 : 1 : check_write(EXESS_TIME, sizeof(a_time), &a_time, 10, "01:02:03Z");
417 : 1 : check_write(EXESS_DATE, sizeof(a_date), &a_date, 12, "2001-02-03Z");
418 : :
419 : : {
420 : 1 : const ExessYearMonth a_year_month = {
421 : 1 : a_date.year, a_date.month, a_date.zone};
422 : 1 : check_write(
423 : : EXESS_YEAR_MONTH, sizeof(a_year_month), &a_year_month, 9, "2001-02Z");
424 : : }
425 : :
426 : : {
427 : 1 : const ExessYear a_year = {a_date.year, a_date.zone};
428 : 1 : check_write(EXESS_YEAR, sizeof(a_year), &a_year, 6, "2001Z");
429 : : }
430 : :
431 : : {
432 : 1 : const ExessMonthDay a_month_day = {a_date.month, a_date.day, a_date.zone};
433 : 1 : check_write(
434 : : EXESS_MONTH_DAY, sizeof(a_month_day), &a_month_day, 9, "--02-03Z");
435 : : }
436 : :
437 : : {
438 : 1 : const ExessDay a_day = {a_date.day, a_date.zone};
439 : 1 : check_write(EXESS_DAY, sizeof(a_day), &a_day, 7, "---03Z");
440 : : }
441 : :
442 : : {
443 : 1 : const ExessMonth a_month = {a_date.month, a_date.zone};
444 : 1 : check_write(EXESS_MONTH, sizeof(a_month), &a_month, 6, "--02Z");
445 : : }
446 : :
447 : 1 : check_write(EXESS_HEX, sizeof(a_blob), a_blob, 7, "666F6F");
448 : 1 : check_write(EXESS_BASE64, sizeof(a_blob), a_blob, 5, "Zm9v");
449 : 1 : }
450 : :
451 : : int
452 : 1 : main(void)
453 : : {
454 : 1 : test_read_value();
455 : 1 : test_write_value();
456 : :
457 : 1 : return 0;
458 : : }
|
