test/unit/unit_test/unit_test_assert_test/unit_test_assert.c

   1 /*
   2  * Copyright (c) 2009-2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include "../../../../inc/test.h"
  19 #if (TEST_MODE == TEST_UNIT)
  20
  21 #include "unit_test_assert.h"
  22
  23 #include <app.h>
  24 #include <math.h>
  25 #include <stdlib.h>
  26 #include <memory.h>
  27
  28 typedef struct __object_t {
  29         int a;
  30         double b;
  31         bool c;
  32         void(*func_a)(void);
  33         void(*func_b)(void);
  34 } object_t;
  35
  36 extern char * __t__get_unit_log_buf(void);
  37
  38 static Eina_Bool __unit_test_assert_bool_ok(void);
  39 static Eina_Bool __unit_test_assert_bool_fail(void);
  40 static Eina_Bool __unit_test_assert_int_ok(void);
  41 static Eina_Bool __unit_test_assert_int_fail(void);
  42 static Eina_Bool __unit_test_assert_double_ok(void);
  43 static Eina_Bool __unit_test_assert_double_fail(void);
  44 static Eina_Bool __unit_test_assert_string_ok(void);
  45 static Eina_Bool __unit_test_assert_string_fail(void);
  46 static Eina_Bool __unit_test_assert_object_ok(void);
  47 static Eina_Bool __unit_test_assert_object_fail(void);
  48 static Eina_Bool __unit_test_assert_log_ok(void);
  49 static Eina_Bool __unit_test_assert_log_fail(void);
  50
  51 static bool __object_equal(const void * object1, const void * object2);
  52
  53 void unit_test_assert(void)
  54 {
  55         __unit_test_run_assert(__unit_test_assert_int_ok() == EINA_TRUE);
  56         __unit_test_run_assert(__unit_test_assert_int_fail() == EINA_FALSE);
  57         __unit_test_run_assert(__unit_test_assert_bool_ok() == EINA_TRUE);
  58         __unit_test_run_assert(__unit_test_assert_bool_fail() == EINA_FALSE);
  59         __unit_test_run_assert(__unit_test_assert_double_ok() == EINA_TRUE);
  60         __unit_test_run_assert(__unit_test_assert_double_fail() == EINA_FALSE);
  61         __unit_test_run_assert(__unit_test_assert_string_ok() == EINA_TRUE);
  62         __unit_test_run_assert(__unit_test_assert_string_fail() == EINA_FALSE);
  63         __unit_test_run_assert(__unit_test_assert_object_ok() == EINA_TRUE);
  64         __unit_test_run_assert(__unit_test_assert_object_fail() == EINA_FALSE);
  65         __unit_test_run_assert(__unit_test_assert_log_ok() == EINA_TRUE);
  66         __unit_test_run_assert(__unit_test_assert_log_fail() == EINA_FALSE);
  67 }
  68
  69 static Eina_Bool __unit_test_assert_bool_ok(void)
  70 {
  71         TEST_ASSERT_TRUE(1);
  72         TEST_ASSERT_TRUE(-1);
  73         TEST_ASSERT_TRUE(987654321);
  74
  75         return EINA_TRUE;
  76 }
  77
  78 static Eina_Bool __unit_test_assert_bool_fail(void)
  79 {
  80         TEST_ASSERT_TRUE(0);
  81
  82         return EINA_TRUE;
  83 }
  84
  85 static Eina_Bool __unit_test_assert_int_ok(void)
  86 {
  87         TEST_ASSERT_EQUAL_INT(1, 1);
  88         TEST_ASSERT_EQUAL_INT(-1, -1);
  89         TEST_ASSERT_EQUAL_INT(987654321, 987654321);
  90
  91         return EINA_TRUE;
  92 }
  93
  94 static Eina_Bool __unit_test_assert_int_fail(void)
  95 {
  96         TEST_ASSERT_EQUAL_INT(100, 100);
  97         TEST_ASSERT_EQUAL_INT(1, 2);
  98         TEST_ASSERT_EQUAL_INT(-1, -1);
  99
 100         return EINA_TRUE;
 101 }
 102
 103 static Eina_Bool __unit_test_assert_double_ok(void)
 104 {
 105         TEST_ASSERT_EQUAL_DOUBLE(1.0, 1.0);
 106         TEST_ASSERT_EQUAL_DOUBLE(0.1, 0.1);
 107         TEST_ASSERT_EQUAL_DOUBLE(0.000001, 0.000001);
 108         TEST_ASSERT_EQUAL_DOUBLE(0.00000000001, 0.00000000002);
 109
 110         return EINA_TRUE;
 111 }
 112
 113 static Eina_Bool __unit_test_assert_double_fail(void)
 114 {
 115         TEST_ASSERT_EQUAL_DOUBLE(0.00000000001, 0.00000000002);
 116         TEST_ASSERT_EQUAL_DOUBLE(0.0000000001, 0.0000000002);
 117
 118         return EINA_TRUE;
 119 }
 120
 121 static Eina_Bool __unit_test_assert_string_ok(void)
 122 {
 123         TEST_ASSERT_EQUAL_STRING("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
 124         TEST_ASSERT_EQUAL_STRING("abcdefg", "abcdefg");
 125         char str1[] = "abcdefghijklmnopqrstuvwxyz";
 126         char str2[] = "abcdefghijklmnopqrstuvwxyz";
 127         TEST_ASSERT_EQUAL_STRING(str1, str2);
 128         TEST_ASSERT_EQUAL_STRING(str1 + 5, str2 + 5);
 129         char str3[] = "abcdefghijklmnopqrstuvwxyz";
 130         char str4[] = "aabcdefghijklmnopqrstuvwxyz";
 131         TEST_ASSERT_EQUAL_STRING(str3, str4+1);
 132
 133         return EINA_TRUE;
 134 }
 135
 136 static Eina_Bool __unit_test_assert_string_fail(void)
 137 {
 138         TEST_ASSERT_EQUAL_STRING("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
 139
 140         char str1[] = "abcdefghijklmnopqrstuvwxyz";
 141         char str2[] = "abcdefghijklmnopqrstuvwxyz";
 142         TEST_ASSERT_EQUAL_STRING(str1, str2 + 1);
 143
 144         return EINA_TRUE;
 145 }
 146
 147 static Eina_Bool __unit_test_assert_object_ok(void)
 148 {
 149         object_t a = { 0, 0, 0, 0, 0 };
 150         object_t b = { 0, 0, 0, 0, 0 };
 151         TEST_ASSERT_EQUAL_OBJECT(&a, &b, __object_equal);
 152         a.a = 1;
 153         b.a = 1;
 154         TEST_ASSERT_EQUAL_OBJECT(&a, &b, __object_equal);
 155         a.b = 0.00000000001;
 156         b.b = 0.00000000002;
 157         TEST_ASSERT_EQUAL_OBJECT(&a, &b, __object_equal);
 158         a.func_a = __unit_test_assert_object_ok;
 159         b.func_a = __unit_test_assert_object_ok;
 160         TEST_ASSERT_EQUAL_OBJECT(&a, &b, __object_equal);
 161
 162         object_t * p_a = (object_t *)malloc(sizeof(object_t));
 163         object_t * p_b = (object_t *)malloc(sizeof(object_t));
 164         memset(p_a, 0, sizeof(object_t));
 165         memset(p_b, 0, sizeof(object_t));
 166         TEST_ASSERT_EQUAL_OBJECT(p_a, p_b, __object_equal);
 167         p_a->a = 1;
 168         p_b->a = 1;
 169         p_a->b = 0.00000000001;
 170         p_b->b = 0.00000000002;
 171         p_a->func_a = __unit_test_assert_object_ok;
 172         p_b->func_a = __unit_test_assert_object_ok;
 173         p_a->c = 1;
 174         p_b->c = 1;
 175         TEST_ASSERT_EQUAL_OBJECT(p_a, p_b, __object_equal);
 176
 177         free(p_a);
 178         free(p_b);
 179
 180         return EINA_TRUE;
 181 }
 182
 183 static Eina_Bool __unit_test_assert_object_fail(void)
 184 {
 185         object_t a = { 0, 0, 0, 0, 0 };
 186         object_t b = { 0, 0, 0, 0, 0 };
 187         TEST_ASSERT_EQUAL_OBJECT(&a, &b, __object_equal);
 188         a.a = 1;
 189         b.a = 1;
 190         TEST_ASSERT_EQUAL_OBJECT(&a, &b, __object_equal);
 191         a.b = 0.0000000001;
 192         b.b = 0.0000000002;
 193         TEST_ASSERT_EQUAL_OBJECT(&a, &b, __object_equal);
 194         a.func_a = __unit_test_assert_object_ok;
 195         b.func_a = __unit_test_assert_object_ok;
 196         TEST_ASSERT_EQUAL_OBJECT(&a, &b, __object_equal);
 197
 198         return EINA_TRUE;
 199 }
 200
 201 static Eina_Bool __unit_test_assert_log_ok(void)
 202 {
 203         char * buf = __t__get_unit_log_buf();
 204         strcpy(buf, "");
 205         TEST_ASSERT_EQUAL_LOG("");
 206
 207         __T("assert");
 208         TEST_ASSERT_EQUAL_LOG("assert\n");
 209         __T("%s", "log");
 210         TEST_ASSERT_EQUAL_LOG("assert\nlog\n");
 211         __T("%d %.2lf ok", 99, 0.01);
 212         TEST_ASSERT_EQUAL_LOG("assert\nlog\n99 0.01 ok\n");
 213
 214         return EINA_TRUE;
 215 }
 216
 217 static Eina_Bool __unit_test_assert_log_fail(void)
 218 {
 219         char * buf = __t__get_unit_log_buf();
 220         strcpy(buf, "");
 221         TEST_ASSERT_EQUAL_LOG("");
 222
 223         __T("assert");
 224         __T("%s", "log");
 225         __T("%d %.2lf ok", 99, 0.01);
 226         TEST_ASSERT_EQUAL_LOG("assert\nlog\n99 0.01 no\n");
 227
 228         return EINA_TRUE;
 229 }
 230
 231 static bool __object_equal(const void * object1, const void * object2)
 232 {
 233         object_t * a = (object_t *)object1;
 234         object_t * b = (object_t *)object2;
 235         if (a->a != b->a) return false;
 236         if (fabs(a->b - b->b) >= 1e-10) return false;
 237         if (a->c != b->c) return false;
 238         if (a->func_a != b->func_a) return false;
 239         if (a->func_b != b->func_b) return false;
 240
 241         return true;
 242 }
 243
 244 #endif