248 lines
5.5 KiB
C
248 lines
5.5 KiB
C
/*
|
|
* Copyright (C) 2013 Tobias Brunner
|
|
* Hochschule fuer Technik Rapperswil
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* for more details.
|
|
*/
|
|
|
|
#include "test_suite.h"
|
|
|
|
#include <utils/utils.h>
|
|
|
|
/*******************************************************************************
|
|
* continuous enum
|
|
*/
|
|
enum {
|
|
CONT1,
|
|
CONT2,
|
|
CONT3,
|
|
CONT4,
|
|
CONT5,
|
|
} test_enum_cont;
|
|
|
|
/* can't be static */
|
|
enum_name_t *test_enum_cont_names;
|
|
|
|
ENUM_BEGIN(test_enum_cont_names, CONT1, CONT5,
|
|
"CONT1", "CONT2", "CONT3", "CONT4", "CONT5");
|
|
ENUM_END(test_enum_cont_names, CONT5);
|
|
|
|
/*******************************************************************************
|
|
* split enum
|
|
*/
|
|
enum {
|
|
SPLIT1 = 1,
|
|
SPLIT2,
|
|
SPLIT3 = 5,
|
|
SPLIT4,
|
|
SPLIT5 = 255,
|
|
} test_enum_split;
|
|
|
|
/* can't be static */
|
|
enum_name_t *test_enum_split_names;
|
|
|
|
ENUM_BEGIN(test_enum_split_names, SPLIT1, SPLIT2,
|
|
"SPLIT1", "SPLIT2");
|
|
ENUM_NEXT(test_enum_split_names, SPLIT3, SPLIT4, SPLIT2,
|
|
"SPLIT3", "SPLIT4");
|
|
ENUM_NEXT(test_enum_split_names, SPLIT5, SPLIT5, SPLIT4,
|
|
"SPLIT5");
|
|
ENUM_END(test_enum_split_names, SPLIT5);
|
|
|
|
/*******************************************************************************
|
|
* enum_to_name
|
|
*/
|
|
|
|
static struct {
|
|
int val;
|
|
char *str;
|
|
} name_tests_cont[] = {
|
|
{-1, NULL},
|
|
{CONT1, "CONT1"},
|
|
{CONT2, "CONT2"},
|
|
{CONT3, "CONT3"},
|
|
{CONT4, "CONT4"},
|
|
{CONT5, "CONT5"},
|
|
{5, NULL},
|
|
}, name_tests_split[] = {
|
|
{-1, NULL},
|
|
{0, NULL},
|
|
{SPLIT1, "SPLIT1"},
|
|
{SPLIT2, "SPLIT2"},
|
|
{3, NULL},
|
|
{4, NULL},
|
|
{SPLIT3, "SPLIT3"},
|
|
{SPLIT4, "SPLIT4"},
|
|
{7, NULL},
|
|
{254, NULL},
|
|
{SPLIT5, "SPLIT5"},
|
|
{256, NULL},
|
|
};
|
|
|
|
START_TEST(test_enum_to_name_cont)
|
|
{
|
|
char *str = enum_to_name(test_enum_cont_names, name_tests_cont[_i].val);
|
|
if (str)
|
|
{
|
|
ck_assert_str_eq(str, name_tests_cont[_i].str);
|
|
}
|
|
else
|
|
{
|
|
ck_assert(str == name_tests_cont[_i].str);
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_enum_to_name_split)
|
|
{
|
|
char *str = enum_to_name(test_enum_split_names, name_tests_split[_i].val);
|
|
if (str)
|
|
{
|
|
ck_assert_str_eq(str, name_tests_split[_i].str);
|
|
}
|
|
else
|
|
{
|
|
ck_assert(str == name_tests_split[_i].str);
|
|
}
|
|
}
|
|
END_TEST
|
|
|
|
/*******************************************************************************
|
|
* enum_from_name
|
|
*/
|
|
|
|
static struct {
|
|
int val;
|
|
char *str;
|
|
} enum_tests_cont[] = {
|
|
{CONT1, "CONT1"},
|
|
{CONT2, "CONT2"},
|
|
{CONT2, "CoNt2"},
|
|
{CONT3, "CONT3"},
|
|
{CONT4, "CONT4"},
|
|
{CONT5, "CONT5"},
|
|
{-1, "asdf"},
|
|
{-1, ""},
|
|
{-1, NULL},
|
|
}, enum_tests_split[] = {
|
|
{SPLIT1, "SPLIT1"},
|
|
{SPLIT1, "split1"},
|
|
{SPLIT2, "SPLIT2"},
|
|
{SPLIT2, "SpLiT2"},
|
|
{SPLIT3, "SPLIT3"},
|
|
{SPLIT4, "SPLIT4"},
|
|
{SPLIT5, "SPLIT5"},
|
|
{-1, "asdf"},
|
|
{-1, ""},
|
|
{-1, NULL},
|
|
};
|
|
|
|
START_TEST(test_enum_from_name_cont)
|
|
{
|
|
int val = enum_from_name(test_enum_cont_names, enum_tests_cont[_i].str);
|
|
ck_assert_int_eq(val, enum_tests_cont[_i].val);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_enum_from_name_split)
|
|
{
|
|
int val = enum_from_name(test_enum_split_names, enum_tests_split[_i].str);
|
|
ck_assert_int_eq(val, enum_tests_split[_i].val);
|
|
}
|
|
END_TEST
|
|
|
|
/*******************************************************************************
|
|
* enum_printf_hook
|
|
*/
|
|
|
|
static struct {
|
|
int val;
|
|
char *str;
|
|
} printf_tests_cont[] = {
|
|
{-1, "(-1)"},
|
|
{CONT1, "CONT1"},
|
|
{CONT2, "CONT2"},
|
|
{CONT3, "CONT3"},
|
|
{CONT4, "CONT4"},
|
|
{CONT5, "CONT5"},
|
|
{5, "(5)"},
|
|
}, printf_tests_split[] = {
|
|
{-1, "(-1)"},
|
|
{0, "(0)"},
|
|
{SPLIT1, "SPLIT1"},
|
|
{SPLIT2, "SPLIT2"},
|
|
{3, "(3)"},
|
|
{4, "(4)"},
|
|
{SPLIT3, "SPLIT3"},
|
|
{SPLIT4, "SPLIT4"},
|
|
{7, "(7)"},
|
|
{254, "(254)"},
|
|
{SPLIT5, "SPLIT5"},
|
|
{256, "(256)"},
|
|
};
|
|
|
|
START_TEST(test_enum_printf_hook_cont)
|
|
{
|
|
char buf[128];
|
|
|
|
snprintf(buf, sizeof(buf), "%N", test_enum_cont_names, printf_tests_cont[_i].val);
|
|
ck_assert_str_eq(printf_tests_cont[_i].str, buf);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_enum_printf_hook_split)
|
|
{
|
|
char buf[128];
|
|
|
|
snprintf(buf, sizeof(buf), "%N", test_enum_split_names, printf_tests_split[_i].val);
|
|
ck_assert_str_eq(printf_tests_split[_i].str, buf);
|
|
}
|
|
END_TEST
|
|
|
|
START_TEST(test_enum_printf_hook_width)
|
|
{
|
|
char buf[128];
|
|
|
|
snprintf(buf, sizeof(buf), "%10N", test_enum_cont_names, CONT1);
|
|
ck_assert_str_eq(" CONT1", buf);
|
|
snprintf(buf, sizeof(buf), "%-*N", 10, test_enum_cont_names, CONT2);
|
|
ck_assert_str_eq("CONT2 ", buf);
|
|
snprintf(buf, sizeof(buf), "%3N", test_enum_cont_names, CONT3);
|
|
ck_assert_str_eq("CONT3", buf);
|
|
}
|
|
END_TEST
|
|
|
|
Suite *enum_suite_create()
|
|
{
|
|
Suite *s;
|
|
TCase *tc;
|
|
|
|
s = suite_create("enum");
|
|
|
|
tc = tcase_create("enum_to_name");
|
|
tcase_add_loop_test(tc, test_enum_to_name_cont, 0, countof(name_tests_cont));
|
|
tcase_add_loop_test(tc, test_enum_to_name_split, 0, countof(name_tests_split));
|
|
suite_add_tcase(s, tc);
|
|
|
|
tc = tcase_create("enum_from_name");
|
|
tcase_add_loop_test(tc, test_enum_from_name_cont, 0, countof(enum_tests_cont));
|
|
tcase_add_loop_test(tc, test_enum_from_name_split, 0, countof(enum_tests_split));
|
|
suite_add_tcase(s, tc);
|
|
|
|
tc = tcase_create("enum_printf_hook");
|
|
tcase_add_loop_test(tc, test_enum_printf_hook_cont, 0, countof(printf_tests_cont));
|
|
tcase_add_loop_test(tc, test_enum_printf_hook_split, 0, countof(printf_tests_split));
|
|
tcase_add_test(tc, test_enum_printf_hook_width);
|
|
suite_add_tcase(s, tc);
|
|
|
|
return s;
|
|
}
|