ctest_refobject.c 7.31 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/* Icecast
 *
 * This program is distributed under the GNU General Public License, version 2.
 * A copy of this license is included with this source.
 *
 * Copyright 2018,      Philipp "ph3-der-loewe" Schafft <lion@lion.leolix.org>,
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <string.h>

#include "ctest_lib.h"

17
#include "../refobject.h"
18 19 20 21 22 23 24 25 26 27 28 29 30 31

static void test_ptr(void)
{
    refobject_t a;

    a = REFOBJECT_NULL;
    ctest_test("NULL is NULL", REFOBJECT_IS_NULL(a));

    if (!REFOBJECT_IS_NULL(a))
        ctest_bailed_out();
}

static void test_create_ref_unref(void)
{
32
    refobject_base_t *a;
33

34
    a = refobject_new__new(refobject_base_t, NULL, NULL, REFOBJECT_NULL);
35 36 37 38 39 40 41
    ctest_test("refobject created", !REFOBJECT_IS_NULL(a));

    ctest_test("referenced", refobject_ref(a) == 0);
    ctest_test("un-referenced (1 of 2)", refobject_unref(a) == 0);
    ctest_test("un-referenced (2 of 2)", refobject_unref(a) == 0);
}

42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
static void test_typename(void)
{
    refobject_base_t *a;
    const char *typename;

    a = refobject_new__new(refobject_base_t, NULL, NULL, REFOBJECT_NULL);
    ctest_test("refobject created", !REFOBJECT_IS_NULL(a));

    typename = REFOBJECT_GET_TYPENAME(a);
    ctest_test("got typename", typename != NULL);
    ctest_test("typename matches", strcmp(typename, "refobject_base_t") == 0);

    ctest_test("un-referenced", refobject_unref(a) == 0);
}

static void test_valid(void)
{
    refobject_base_t *a;

    typedef struct {
        refobject_base_t __base;
    } ctest_test_type_t;

65
    REFOBJECT_DEFINE_PRIVATE_TYPE(ctest_test_type_t);
66 67 68 69 70 71 72 73 74 75 76 77

    ctest_test("NULL is not valid", !REFOBJECT_IS_VALID(REFOBJECT_NULL, refobject_base_t));

    a = refobject_new__new(refobject_base_t, NULL, NULL, REFOBJECT_NULL);
    ctest_test("refobject created", !REFOBJECT_IS_NULL(a));

    ctest_test("is valid", REFOBJECT_IS_VALID(a, refobject_base_t));
    ctest_test("is valid as diffrent type", !REFOBJECT_IS_VALID(a, ctest_test_type_t));

    ctest_test("un-referenced", refobject_unref(a) == 0);
}

78 79 80 81
static void test_sizes(void)
{
    refobject_t a;

82 83 84 85
    typedef struct {
        refobject_base_t __base;
        char padding[1024];
    } ctest_test_type_a_t;
86
    REFOBJECT_DEFINE_PRIVATE_TYPE(ctest_test_type_a_t);
87 88 89 90 91

    typedef struct {
        refobject_base_t __base;
        char padding[131072];
    } ctest_test_type_b_t;
92
    REFOBJECT_DEFINE_PRIVATE_TYPE(ctest_test_type_b_t);
93 94 95 96

    typedef struct {
        char padding[sizeof(refobject_base_t) - 1];
    } ctest_test_type_c_t;
97
    REFOBJECT_DEFINE_PRIVATE_TYPE(ctest_test_type_c_t);
98 99 100 101

    typedef struct {
        char padding[0];
    } ctest_test_type_d_t;
102
    REFOBJECT_DEFINE_PRIVATE_TYPE(ctest_test_type_d_t);
103 104

    a = REFOBJECT_FROM_TYPE(refobject_new__new(ctest_test_type_a_t, NULL, NULL, REFOBJECT_NULL));
105 106 107
    ctest_test("refobject created with size=sizeof(refobject_base_t) + 1024", !REFOBJECT_IS_NULL(a));
    ctest_test("un-referenced", refobject_unref(a) == 0);

108
    a = REFOBJECT_FROM_TYPE(refobject_new__new(ctest_test_type_b_t, NULL, NULL, REFOBJECT_NULL));
109 110 111
    ctest_test("refobject created with size=sizeof(refobject_base_t) + 131072", !REFOBJECT_IS_NULL(a));
    ctest_test("un-referenced", refobject_unref(a) == 0);

112 113 114 115
    a = REFOBJECT_FROM_TYPE(refobject_new__new(ctest_test_type_c_t, NULL, NULL, REFOBJECT_NULL));
    ctest_test("refobject created with size=sizeof(refobject_base_t) - 1", REFOBJECT_IS_NULL(a));
    if (!REFOBJECT_IS_NULL(a)) {
        ctest_test("un-referenced", refobject_unref(a) == 0);
116 117
    }

118
    a = REFOBJECT_FROM_TYPE(refobject_new__new(ctest_test_type_d_t, NULL, NULL, REFOBJECT_NULL));
119 120 121 122 123 124
    ctest_test("refobject created with size=0", REFOBJECT_IS_NULL(a));
    if (!REFOBJECT_IS_NULL(a)) {
        ctest_test("un-referenced", refobject_unref(a) == 0);
    }
}

125 126
static void test_name(void)
{
127
    refobject_base_t *a;
128 129 130
    const char *name = "test object name";
    const char *ret;

131
    a = refobject_new__new(refobject_base_t, NULL, name, REFOBJECT_NULL);
132 133 134 135 136 137 138 139 140 141 142
    ctest_test("refobject created", !REFOBJECT_IS_NULL(a));

    ret = refobject_get_name(a);
    ctest_test("get name", ret != NULL);
    ctest_test("name match", strcmp(name, ret) == 0);

    ctest_test("un-referenced", refobject_unref(a) == 0);
}

static void test_userdata(void)
{
143
    refobject_base_t *a;
144 145 146 147
    int tmp = 0;
    void *userdata = &tmp;
    void *ret;

148
    a = refobject_new__new(refobject_base_t, NULL, NULL, REFOBJECT_NULL);
149 150 151 152 153 154 155 156 157 158 159 160 161
    ctest_test("refobject created", !REFOBJECT_IS_NULL(a));

    ret = refobject_get_userdata(a);
    ctest_test("get userdata", ret == NULL);
    ctest_test("set userdata", refobject_set_userdata(a, userdata) == 0);
    ret = refobject_get_userdata(a);
    ctest_test("get userdata", ret == userdata);
    ctest_test("clearing userdata", refobject_set_userdata(a, NULL) == 0);
    ret = refobject_get_userdata(a);
    ctest_test("get userdata", ret == NULL);

    ctest_test("un-referenced", refobject_unref(a) == 0);

162
    a = refobject_new__new(refobject_base_t, userdata, NULL, REFOBJECT_NULL);
163 164 165 166 167 168 169 170 171 172 173
    ctest_test("refobject created", !REFOBJECT_IS_NULL(a));
    ret = refobject_get_userdata(a);
    ctest_test("get userdata", ret == userdata);
    ctest_test("clearing userdata", refobject_set_userdata(a, NULL) == 0);
    ret = refobject_get_userdata(a);
    ctest_test("get userdata", ret == NULL);
    ctest_test("un-referenced", refobject_unref(a) == 0);
}

static void test_associated(void)
{
174
    refobject_base_t *a, *b;
175

176
    a = refobject_new__new(refobject_base_t, NULL, NULL, REFOBJECT_NULL);
177 178
    ctest_test("refobject created", !REFOBJECT_IS_NULL(a));

179
    b = refobject_new__new(refobject_base_t, NULL, NULL, a);
180 181 182 183 184 185
    ctest_test("refobject created with associated", !REFOBJECT_IS_NULL(b));

    ctest_test("un-referenced (1 of 2)", refobject_unref(b) == 0);
    ctest_test("un-referenced (2 of 2)", refobject_unref(a) == 0);
}

186 187 188 189 190 191
static size_t test_freecb__called;
static void test_freecb__freecb(refobject_t self, void **userdata)
{
    test_freecb__called++;
}

192 193
static void test_freecb(void)
{
194 195 196 197 198 199 200 201
    typedef struct {
        refobject_base_t __base;
    } ctest_test_type_t;
    ctest_test_type_t *a;

    REFOBJECT_DEFINE_PRIVATE_TYPE(ctest_test_type_t,
            REFOBJECT_DEFINE_TYPE_FREE(test_freecb__freecb)
            );
202

203
    test_freecb__called = 0;
204 205 206
    a = refobject_new__new(ctest_test_type_t, NULL, NULL, REFOBJECT_NULL);
    ctest_test("refobject created", a != NULL);
    ctest_test("un-referenced", refobject_unref(REFOBJECT_FROM_TYPE(a)) == 0);
207
    ctest_test("freecb called", test_freecb__called == 1);
208

209
    test_freecb__called = 0;
210 211 212
    a = refobject_new__new(ctest_test_type_t, NULL, NULL, REFOBJECT_NULL);
    ctest_test("refobject created", a != NULL);
    ctest_test("referenced", refobject_ref(REFOBJECT_FROM_TYPE(a)) == 0);
213
    ctest_test("freecb uncalled", test_freecb__called == 0);
214
    ctest_test("un-referenced (1 of 2)", refobject_unref(REFOBJECT_FROM_TYPE(a)) == 0);
215
    ctest_test("freecb uncalled", test_freecb__called == 0);
216
    ctest_test("un-referenced (2 of 2)", refobject_unref(REFOBJECT_FROM_TYPE(a)) == 0);
217
    ctest_test("freecb called", test_freecb__called == 1);
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
}

int main (void)
{
    ctest_init();

    test_ptr();

    if (ctest_bailed_out()) {
        ctest_fin();
        return 1;
    }

    test_create_ref_unref();

233 234 235
    test_typename();
    test_valid();

236 237
    test_sizes();

238 239 240 241 242 243 244 245 246
    test_name();
    test_userdata();
    test_associated();
    test_freecb();

    ctest_fin();

    return 0;
}