Home | History | Annotate | Line # | Download | only in test 
      1 /*
      2  * Copyright (c) 2014-2019 Pavel Kalvoda <me (at) pavelkalvoda.com>
      3  *
      4  * libcbor is free software; you can redistribute it and/or modify
      5  * it under the terms of the MIT license. See LICENSE for details.
      6  */
      7 
      8 #include <setjmp.h>
      9 #include <stdarg.h>
     10 #include <stddef.h>
     11 
     12 #include <cmocka.h>
     13 
     14 #include "assertions.h"
     15 #include "cbor.h"
     16 
     17 cbor_item_t *item, *copy, *tmp;
     18 
     19 static void test_uints(void **state) {
     20   item = cbor_build_uint8(10);
     21   assert_uint8(copy = cbor_copy(item), 10);
     22   cbor_decref(&item);
     23   cbor_decref(&copy);
     24 
     25   item = cbor_build_uint16(10);
     26   assert_uint16(copy = cbor_copy(item), 10);
     27   cbor_decref(&item);
     28   cbor_decref(&copy);
     29 
     30   item = cbor_build_uint32(10);
     31   assert_uint32(copy = cbor_copy(item), 10);
     32   cbor_decref(&item);
     33   cbor_decref(&copy);
     34 
     35   item = cbor_build_uint64(10);
     36   assert_uint64(copy = cbor_copy(item), 10);
     37   cbor_decref(&item);
     38   cbor_decref(&copy);
     39 }
     40 
     41 static void test_negints(void **state) {
     42   item = cbor_build_negint8(10);
     43   assert_true(cbor_get_uint8(copy = cbor_copy(item)) == 10);
     44   cbor_decref(&item);
     45   cbor_decref(&copy);
     46 
     47   item = cbor_build_negint16(10);
     48   assert_true(cbor_get_uint16(copy = cbor_copy(item)) == 10);
     49   cbor_decref(&item);
     50   cbor_decref(&copy);
     51 
     52   item = cbor_build_negint32(10);
     53   assert_true(cbor_get_uint32(copy = cbor_copy(item)) == 10);
     54   cbor_decref(&item);
     55   cbor_decref(&copy);
     56 
     57   item = cbor_build_negint64(10);
     58   assert_true(cbor_get_uint64(copy = cbor_copy(item)) == 10);
     59   cbor_decref(&item);
     60   cbor_decref(&copy);
     61 }
     62 
     63 static void test_def_bytestring(void **state) {
     64   item = cbor_build_bytestring((cbor_data) "abc", 3);
     65   assert_memory_equal(cbor_bytestring_handle(copy = cbor_copy(item)),
     66                       cbor_bytestring_handle(item), 3);
     67   cbor_decref(&item);
     68   cbor_decref(&copy);
     69 }
     70 
     71 static void test_indef_bytestring(void **state) {
     72   item = cbor_new_indefinite_bytestring();
     73   cbor_bytestring_add_chunk(
     74       item, cbor_move(cbor_build_bytestring((cbor_data) "abc", 3)));
     75   copy = cbor_copy(item);
     76 
     77   assert_int_equal(cbor_bytestring_chunk_count(item),
     78                    cbor_bytestring_chunk_count(copy));
     79 
     80   assert_memory_equal(
     81       cbor_bytestring_handle(cbor_bytestring_chunks_handle(copy)[0]), "abc", 3);
     82   cbor_decref(&item);
     83   cbor_decref(&copy);
     84 }
     85 
     86 static void test_def_string(void **state) {
     87   item = cbor_build_string("abc");
     88   assert_memory_equal(cbor_string_handle(copy = cbor_copy(item)),
     89                       cbor_string_handle(item), 3);
     90   cbor_decref(&item);
     91   cbor_decref(&copy);
     92 }
     93 
     94 static void test_indef_string(void **state) {
     95   item = cbor_new_indefinite_string();
     96   cbor_string_add_chunk(item, cbor_move(cbor_build_string("abc")));
     97   copy = cbor_copy(item);
     98 
     99   assert_int_equal(cbor_string_chunk_count(item),
    100                    cbor_string_chunk_count(copy));
    101 
    102   assert_memory_equal(cbor_string_handle(cbor_string_chunks_handle(copy)[0]),
    103                       "abc", 3);
    104   cbor_decref(&item);
    105   cbor_decref(&copy);
    106 }
    107 
    108 static void test_def_array(void **state) {
    109   item = cbor_new_definite_array(1);
    110   cbor_array_push(item, cbor_move(cbor_build_uint8(42)));
    111 
    112   assert_uint8(tmp = cbor_array_get(copy = cbor_copy(item), 0), 42);
    113   cbor_decref(&item);
    114   cbor_decref(&copy);
    115   cbor_decref(&tmp);
    116 }
    117 
    118 static void test_indef_array(void **state) {
    119   item = cbor_new_indefinite_array();
    120   cbor_array_push(item, cbor_move(cbor_build_uint8(42)));
    121 
    122   assert_uint8(tmp = cbor_array_get(copy = cbor_copy(item), 0), 42);
    123   cbor_decref(&item);
    124   cbor_decref(&copy);
    125   cbor_decref(&tmp);
    126 }
    127 
    128 static void test_def_map(void **state) {
    129   item = cbor_new_definite_map(1);
    130   cbor_map_add(item, (struct cbor_pair){
    131                          .key = cbor_move(cbor_build_uint8(42)),
    132                          .value = cbor_move(cbor_build_uint8(43)),
    133                      });
    134 
    135   assert_uint8(cbor_map_handle(copy = cbor_copy(item))[0].key, 42);
    136 
    137   cbor_decref(&item);
    138   cbor_decref(&copy);
    139 }
    140 
    141 static void test_indef_map(void **state) {
    142   item = cbor_new_indefinite_map(1);
    143   cbor_map_add(item, (struct cbor_pair){
    144                          .key = cbor_move(cbor_build_uint8(42)),
    145                          .value = cbor_move(cbor_build_uint8(43)),
    146                      });
    147 
    148   assert_uint8(cbor_map_handle(copy = cbor_copy(item))[0].key, 42);
    149 
    150   cbor_decref(&item);
    151   cbor_decref(&copy);
    152 }
    153 
    154 static void test_tag(void **state) {
    155   item = cbor_build_tag(10, cbor_move(cbor_build_uint8(42)));
    156 
    157   assert_uint8(cbor_tag_item(copy = cbor_copy(item)), 42);
    158 
    159   cbor_decref(&item);
    160   cbor_decref(&copy);
    161 }
    162 
    163 static void test_ctrls(void **state) {
    164   item = cbor_new_null();
    165   assert_true(cbor_is_null(copy = cbor_copy(item)));
    166   cbor_decref(&item);
    167   cbor_decref(&copy);
    168 }
    169 
    170 static void test_floats(void **state) {
    171   item = cbor_build_float2(3.14f);
    172   assert_true(cbor_float_get_float2(copy = cbor_copy(item)) ==
    173               cbor_float_get_float2(item));
    174   cbor_decref(&item);
    175   cbor_decref(&copy);
    176 
    177   item = cbor_build_float4(3.14f);
    178   assert_true(cbor_float_get_float4(copy = cbor_copy(item)) ==
    179               cbor_float_get_float4(item));
    180   cbor_decref(&item);
    181   cbor_decref(&copy);
    182 
    183   item = cbor_build_float8(3.14);
    184   assert_true(cbor_float_get_float8(copy = cbor_copy(item)) ==
    185               cbor_float_get_float8(item));
    186   cbor_decref(&item);
    187   cbor_decref(&copy);
    188 }
    189 
    190 int main(void) {
    191   const struct CMUnitTest tests[] = {
    192 
    193       cmocka_unit_test(test_uints),
    194       cmocka_unit_test(test_negints),
    195       cmocka_unit_test(test_def_bytestring),
    196       cmocka_unit_test(test_indef_bytestring),
    197       cmocka_unit_test(test_def_string),
    198       cmocka_unit_test(test_indef_string),
    199       cmocka_unit_test(test_def_array),
    200       cmocka_unit_test(test_indef_array),
    201       cmocka_unit_test(test_def_map),
    202       cmocka_unit_test(test_indef_map),
    203       cmocka_unit_test(test_tag),
    204       cmocka_unit_test(test_ctrls),
    205       cmocka_unit_test(test_floats)};
    206   return cmocka_run_group_tests(tests, NULL, NULL);
    207 }
    208