base/test_base.c

   1 /*
   2  * Copyright (c) 2010 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Portions Copyright (c) 2010 Apple Inc. All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * 3. Neither the name of the Institute nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39
  40 #include "heimbase.h"
  41 #include "heimbasepriv.h"
  42
  43 static void
  44 memory_free(heim_object_t obj)
  45 {
  46 }
  47
  48 static int
  49 test_memory(void)
  50 {
  51     void *ptr;
  52
  53     ptr = heim_alloc(10, "memory", memory_free);
  54
  55     heim_retain(ptr);
  56     heim_release(ptr);
  57
  58     heim_retain(ptr);
  59     heim_release(ptr);
  60
  61     heim_release(ptr);
  62
  63     ptr = heim_alloc(10, "memory", NULL);
  64     heim_release(ptr);
  65
  66     return 0;
  67 }
  68
  69 static int
  70 test_dict(void)
  71 {
  72     heim_dict_t dict;
  73     heim_number_t a1 = heim_number_create(1);
  74     heim_string_t a2 = heim_string_create("hejsan");
  75     heim_number_t a3 = heim_number_create(3);
  76     heim_string_t a4 = heim_string_create("foosan");
  77
  78     dict = heim_dict_create(10);
  79
  80     heim_dict_set_value(dict, a1, a2);
  81     heim_dict_set_value(dict, a3, a4);
  82
  83     heim_dict_delete_key(dict, a3);
  84     heim_dict_delete_key(dict, a1);
  85
  86     heim_release(a1);
  87     heim_release(a2);
  88     heim_release(a3);
  89     heim_release(a4);
  90
  91     heim_release(dict);
  92
  93     return 0;
  94 }
  95
  96 static int
  97 test_auto_release(void)
  98 {
  99     heim_auto_release_t ar1, ar2;
 100     heim_number_t n1;
 101     heim_string_t s1;
 102
 103     ar1 = heim_auto_release_create();
 104
 105     s1 = heim_string_create("hejsan");
 106     heim_auto_release(s1);
 107
 108     n1 = heim_number_create(1);
 109     heim_auto_release(n1);
 110
 111     ar2 = heim_auto_release_create();
 112
 113     n1 = heim_number_create(1);
 114     heim_auto_release(n1);
 115
 116     heim_release(ar2);
 117     heim_release(ar1);
 118
 119     return 0;
 120 }
 121
 122 static int
 123 test_string(void)
 124 {
 125     heim_string_t s1, s2;
 126     const char *string = "hejsan";
 127
 128     s1 = heim_string_create(string);
 129     s2 = heim_string_create(string);
 130
 131     if (heim_cmp(s1, s2) != 0) {
 132         printf("the same string is not the same\n");
 133         exit(1);
 134     }
 135
 136     heim_release(s1);
 137     heim_release(s2);
 138
 139     return 0;
 140 }
 141
 142 static int
 143 test_error(void)
 144 {
 145     heim_error_t e;
 146     heim_string_t s;
 147
 148     e = heim_error_create(10, "foo: %s", "bar");
 149     heim_assert(heim_error_get_code(e) == 10, "error_code != 10");
 150
 151     s = heim_error_copy_string(e);
 152     heim_assert(strcmp(heim_string_get_utf8(s), "foo: bar") == 0, "msg wrong");
 153
 154     heim_release(s);
 155     heim_release(e);
 156
 157     return 0;
 158 }
 159
 160 static int
 161 test_json(void)
 162 {
 163     heim_object_t o, o2;
 164     heim_string_t k1 = heim_string_create("k1");
 165
 166     o = heim_json_create("\"string\"", NULL);
 167     heim_assert(o != NULL, "string");
 168     heim_assert(heim_get_tid(o) == heim_string_get_type_id(), "string-tid");
 169     heim_assert(strcmp("string", heim_string_get_utf8(o)) == 0, "wrong string");
 170     heim_release(o);
 171
 172     o = heim_json_create(" \"foo\\\"bar\" ]", NULL);
 173     heim_assert(o != NULL, "string");
 174     heim_assert(heim_get_tid(o) == heim_string_get_type_id(), "string-tid");
 175     heim_assert(strcmp("foo\"bar", heim_string_get_utf8(o)) == 0, "wrong string");
 176     heim_release(o);
 177
 178     o = heim_json_create(" { \"key\" : \"value\" }", NULL);
 179     heim_assert(o != NULL, "dict");
 180     heim_assert(heim_get_tid(o) == heim_dict_get_type_id(), "dict-tid");
 181     heim_release(o);
 182
 183     o = heim_json_create(" { \"k1\" : \"s1\", \"k2\" : \"s2\" }", NULL);
 184     heim_assert(o != NULL, "dict");
 185     heim_assert(heim_get_tid(o) == heim_dict_get_type_id(), "dict-tid");
 186     o2 = heim_dict_get_value(o, k1);
 187     heim_assert(heim_get_tid(o2) == heim_string_get_type_id(), "string-tid");
 188     heim_release(o);
 189
 190     o = heim_json_create(" { \"k1\" : { \"k2\" : \"s2\" } }", NULL);
 191     heim_assert(o != NULL, "dict");
 192     heim_assert(heim_get_tid(o) == heim_dict_get_type_id(), "dict-tid");
 193     o2 = heim_dict_get_value(o, k1);
 194     heim_assert(heim_get_tid(o2) == heim_dict_get_type_id(), "dict-tid");
 195     heim_release(o);
 196
 197     o = heim_json_create("{ \"k1\" : 1 }", NULL);
 198     heim_assert(o != NULL, "array");
 199     heim_assert(heim_get_tid(o) == heim_dict_get_type_id(), "dict-tid");
 200     o2 = heim_dict_get_value(o, k1);
 201     heim_assert(heim_get_tid(o2) == heim_number_get_type_id(), "number-tid");
 202     heim_release(o);
 203
 204     o = heim_json_create("-10", NULL);
 205     heim_assert(o != NULL, "number");
 206     heim_assert(heim_get_tid(o) == heim_number_get_type_id(), "number-tid");
 207     heim_release(o);
 208
 209     o = heim_json_create("99", NULL);
 210     heim_assert(o != NULL, "number");
 211     heim_assert(heim_get_tid(o) == heim_number_get_type_id(), "number-tid");
 212     heim_release(o);
 213
 214     o = heim_json_create(" [ 1 ]", NULL);
 215     heim_assert(o != NULL, "array");
 216     heim_assert(heim_get_tid(o) == heim_array_get_type_id(), "array-tid");
 217     heim_release(o);
 218
 219     o = heim_json_create(" [ -1 ]", NULL);
 220     heim_assert(o != NULL, "array");
 221     heim_assert(heim_get_tid(o) == heim_array_get_type_id(), "array-tid");
 222     heim_release(o);
 223
 224     heim_release(k1);
 225
 226     return 0;
 227 }
 228
 229
 230 int
 231 main(int argc, char **argv)
 232 {
 233     int res = 0;
 234
 235     res |= test_memory();
 236     res |= test_dict();
 237     res |= test_auto_release();
 238     res |= test_string();
 239     res |= test_error();
 240     res |= test_json();
 241
 242     return res ? 1 : 0;
 243 }