diff options
Diffstat (limited to 'utest')
| -rw-r--r-- | utest/.gitignore | 1 | ||||
| -rw-r--r-- | utest/Makefile | 38 | ||||
| -rw-r--r-- | utest/README | 17 | ||||
| -rw-r--r-- | utest/trace-utest.c | 86 | ||||
| -rw-r--r-- | utest/trace-utest.h | 14 | ||||
| -rw-r--r-- | utest/traceevent-utest.c | 429 |
6 files changed, 585 insertions, 0 deletions
diff --git a/utest/.gitignore b/utest/.gitignore new file mode 100644 index 0000000..3620cd0 --- /dev/null +++ b/utest/.gitignore @@ -0,0 +1 @@ +trace-utest diff --git a/utest/Makefile b/utest/Makefile new file mode 100644 index 0000000..160bdb4 --- /dev/null +++ b/utest/Makefile @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: LGPL-2.1 + +include $(src)/scripts/utils.mk + +TARGETS = $(bdir)/trace-utest + +OBJS = +OBJS += trace-utest.o +OBJS += traceevent-utest.o + +LIBS += -lcunit \ + -ldl \ + $(LIBTRACEEVENT_STATIC) + +OBJS := $(OBJS:%.o=$(bdir)/%.o) +DEPS := $(OBJS:$(bdir)/%.o=$(bdir)/.%.d) + +$(OBJS): | $(bdir) +$(DEPS): | $(bdir) + +$(bdir)/trace-utest: $(OBJS) $(LIBTRACEEVENT_STATIC) + $(Q)$(do_app_build) + +$(bdir)/%.o: %.c + $(Q)$(call do_fpic_compile) + +$(DEPS): $(bdir)/.%.d: %.c + $(Q)$(CC) -M $(CPPFLAGS) $(CFLAGS) $< > $@ + $(Q)$(CC) -M -MT $(bdir)/$*.o $(CPPFLAGS) $(CFLAGS) $< > $@ + +$(OBJS): $(bdir)/%.o : $(bdir)/.%.d + +dep_includes := $(wildcard $(DEPS)) + +test: $(TARGETS) + +clean: + $(Q)$(call do_clean,$(TARGETS) $(bdir)/*.o $(bdir)/.*.d) diff --git a/utest/README b/utest/README new file mode 100644 index 0000000..87d6bd9 --- /dev/null +++ b/utest/README @@ -0,0 +1,17 @@ + +Unit tests for libtraceevent library. The tests use CUnit framework: + + http://cunit.sourceforge.net/ + +which must be pre installed on the system, before building the unit tests. +The framework can be downloaded, compiled and installed manually, or +using a precompiled distro package: + + Fedora: + CUnit + CUnit-devel + + Ubuntu and Debian: + libcunit1 + libcunit1-doc + libcunit1-dev diff --git a/utest/trace-utest.c b/utest/trace-utest.c new file mode 100644 index 0000000..1403c86 --- /dev/null +++ b/utest/trace-utest.c @@ -0,0 +1,86 @@ +// SPDX-License-Identifier: LGPL-2.1 +/* + * Copyright (C) 2020, VMware, Tzvetomir Stoyanov <tz.stoyanov@gmail.com> + * + * Modified from libtracefs to libtraceevent: + * Copyright (C) 2021, VMware, Steven Rostedt <rostedt@goodmis.org> + * + */ +#include <stdio.h> +#include <unistd.h> +#include <getopt.h> +#include <stdlib.h> + +#include <CUnit/CUnit.h> +#include <CUnit/Basic.h> + +#include "trace-utest.h" + +enum unit_tests { + RUN_NONE = 0, + RUN_TRACEEVENT = (1 << 0), + RUN_ALL = 0xFFFF +}; + +static void print_help(char **argv) +{ + printf("Usage: %s [OPTIONS]\n", basename(argv[0])); + printf("\t-s, --silent\tPrint test summary\n"); + printf("\t-r, --run test\tRun specific test:\n"); + printf("\t\t traceevent run libtraceevent tests\n"); + printf("\t-h, --help\tPrint usage information\n"); + exit(0); +} + +int main(int argc, char **argv) +{ + CU_BasicRunMode verbose = CU_BRM_VERBOSE; + enum unit_tests tests = RUN_NONE; + + for (;;) { + int c; + int index = 0; + const char *opts = "+hsr:"; + static struct option long_options[] = { + {"silent", no_argument, NULL, 's'}, + {"run", required_argument, NULL, 'r'}, + {"help", no_argument, NULL, 'h'}, + {NULL, 0, NULL, 0} + }; + + c = getopt_long (argc, argv, opts, long_options, &index); + if (c == -1) + break; + switch (c) { + case 'r': + if (strcmp(optarg, "traceevent") == 0) + tests |= RUN_TRACEEVENT; + else + print_help(argv); + break; + case 's': + verbose = CU_BRM_SILENT; + break; + case 'h': + default: + print_help(argv); + break; + } + } + + if (tests == RUN_NONE) + tests = RUN_ALL; + + if (CU_initialize_registry() != CUE_SUCCESS) { + printf("Test registry cannot be initialized\n"); + return -1; + } + + if (tests & RUN_TRACEEVENT) + test_traceevent_lib(); + + CU_basic_set_mode(verbose); + CU_basic_run_tests(); + CU_cleanup_registry(); + return 0; +} diff --git a/utest/trace-utest.h b/utest/trace-utest.h new file mode 100644 index 0000000..2aa3455 --- /dev/null +++ b/utest/trace-utest.h @@ -0,0 +1,14 @@ +/* SPDX-License-Identifier: LGPL-2.1 */ +/* + * Copyright (C) 2020, VMware, Tzvetomir Stoyanov <tz.stoyanov@gmail.com> + * + * Modified from libtracefs to libtraceevent: + * Copyright (C) 2021, VMware, Steven Rostedt <rostedt@goodmis.org> + * + */ +#ifndef _TRACE_UTEST_H_ +#define _TRACE_UTEST_H_ + +void test_traceevent_lib(void); + +#endif /* _TRACE_UTEST_H_ */ diff --git a/utest/traceevent-utest.c b/utest/traceevent-utest.c new file mode 100644 index 0000000..ebd5eb9 --- /dev/null +++ b/utest/traceevent-utest.c @@ -0,0 +1,429 @@ +// SPDX-License-Identifier: LGPL-2.1 +/* + * Copyright (C) 2020, VMware, Tzvetomir Stoyanov <tz.stoyanov@gmail.com> + * + * Modified from libtracefs to libtraceevent: + * Copyright (C) 2021, VMware, Steven Rostedt <rostedt@goodmis.org> + * + */ +#include <stdio.h> +#include <stdlib.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <time.h> +#include <dirent.h> +#include <ftw.h> + +#include <CUnit/CUnit.h> +#include <CUnit/Basic.h> + +#include "event-parse.h" +#include "trace-seq.h" + +#define TRACEEVENT_SUITE "traceevent library" + +#define DYN_STR_EVENT_SYSTEM "irq" +#define DYN_STR_FIELD "name" +#define DYN_STRING "hello" +#define DYN_STRING_FMT "irq=0 handler=hello" +static const char dyn_str_event[] = + "name: irq_handler_entry\n" + "ID: 1\n" + "format:\n" + "\tfield:unsigned short common_type;\toffset:0;\tsize:2;\tsigned:0;\n" + "\tfield:unsigned char common_flags;\toffset:2;\tsize:1;\tsigned:0;\n" + "\tfield:unsigned char common_preempt_count;\toffset:3;\tsize:1;\tsigned:0;\n" + "\tfield:int common_pid;\toffset:4;\tsize:4;\tsigned:1;\n" + "\n" + "\tfield:int irq;\toffset:8;\tsize:4;\tsigned:1;\n" + "\tfield:__data_loc char[] name;\toffset:12;\tsize:4;\tsigned:1;\n" + "\n" + "print fmt: \"irq=%d handler=%s\", REC->irq, __get_str(name)\n"; + +static char dyn_str_data[] = { +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + /* common type */ 1, 0x00, +#else + /* common type */ 0x00, 1 +#endif + /* common flags */ 0x00, + /* common_preempt_count */ 0x00, + /* common_pid */ 0x00, 0x00, 0x00, 0x00, + /* irq */ 0x00, 0x00, 0x00, 0x00, + +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + /* name : offset */ 16, 0x00, + /* name : length */ 6, 0x00, +#else + /* name : length */ 0x00, 6, + /* name : offset */ 0x00, 16, +#endif + /* name */ 'h', 'e', 'l', 'l', 'o', '\0', + /* padding */ 0x00, 0x00 +}; +static void *dyn_str_event_data = (void *)dyn_str_data; + +static const char dyn_str_old_event[] = + "name: irq_handler_entry\n" + "ID: 2\n" + "format:\n" + "\tfield:unsigned short common_type;\toffset:0;\tsize:2;\n" + "\tfield:unsigned char common_flags;\toffset:2;\tsize:1;\n" + "\tfield:unsigned char common_preempt_count;\toffset:3;\tsize:1;\n" + "\tfield:int common_pid;\toffset:4;\tsize:4;\n" + "\n" + "\tfield:int irq;\toffset:8;\tsize:4;\n" + "\tfield:__data_loc name;\toffset:12;\tsize:2;\n" + "\n" + "print fmt: \"irq=%d handler=%s\", REC->irq, __get_str(name)\n"; + +static char dyn_str_old_data[] = { +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + /* common type */ 2, 0x00, +#else + /* common type */ 0x00, 2 +#endif + /* common flags */ 0x00, + /* common_preempt_count */ 0x00, + /* common_pid */ 0x00, 0x00, 0x00, 0x00, + /* irq */ 0x00, 0x00, 0x00, 0x00, + +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + /* name : offset */ 16, 0x00, +#else + /* name : offset */ 0x00, 16, +#endif + /* padding */ 0x00, 0x00, + /* name */ 'h', 'e', 'l', 'l', 'o', '\0', + /* padding */ 0x00, 0x00, 0x00 +}; +static void *dyn_str_old_event_data = (void *)dyn_str_old_data; + +#define CPUMASK_EVENT_SYSTEM "ipi" +#define CPUMASK_EVENT_FIELD "cpumask" +static const char cpumask_event_format[] = + "name: ipi_send_cpumask\n" + "ID: 3\n" + "format:\n" + "\tfield:unsigned short common_type;\toffset:0;\tsize:2;\n" + "\tfield:unsigned char common_flags;\toffset:2;\tsize:1;\n" + "\tfield:unsigned char common_preempt_count;\toffset:3;\tsize:1;\n" + "\tfield:int common_pid;\toffset:4;\tsize:4;\n" + "\n" + "\tfield:__data_loc cpumask_t *[] cpumask;\toffset:8;\tsize:4;\tsigned:0;\n" + "\n" + "print fmt: \"cpumask=%s\", __get_cpumask(cpumask)\n"; + +/* Mind the endianness! */ +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +#define DECL_CPUMASK_EVENT_DATA(name, args...) \ + static char cpumask_##name##_event_data[] = { \ + /* common type */ 3, 0x00, \ + /* common flags */ 0x00, \ + /* common_preempt_count */ 0x00, \ + /* common_pid */ 0x00, 0x00, 0x00, 0x00, \ + /* [offset, size] */ 16, 0x00, 8, 0x00, \ + /* padding */ 0x00, 0x00, 0x00, 0x00, \ + /* cpumask */ args, \ +} +#else +#define DECL_CPUMASK_EVENT_DATA(name, args...) \ +static char cpumask_##name##_event_data[] = { \ + /* common type */ 0x00, 3, \ + /* common flags */ 0x00, \ + /* common_preempt_count */ 0x00, \ + /* common_pid */ 0x00, 0x00, 0x00, 0x00, \ + /* [offset, size] */ 0x00, 8, 0x00, 16, \ + /* padding */ 0x00, 0x00, 0x00, 0x00, \ + /* cpumask */ args, \ +} +#endif + +#define SIZEOF_LONG0_FMT "[FAILED TO PARSE] s4=0 u4=0 s8=0 u8=0x0" +#define SIZEOF_LONG4_FMT "int=4 unsigned=4 unsigned int=4 long=4 unsigned long=4 long long=8 unsigned long long=8 s4=4 u4=4 s8=8 u8=8" +#define SIZEOF_LONG8_FMT "int=4 unsigned=4 unsigned int=4 long=8 unsigned long=8 long long=8 unsigned long long=8 s4=4 u4=4 s8=8 u8=8" + +static const char size_of_event[] = + "name: sizeof_event\n" + "ID: 23\n" + "format:\n" + "\tfield:unsigned short common_type;\toffset:0;\tsize:2;\tsigned:0;\n" + "\tfield:unsigned char common_flags;\toffset:2;\tsize:1;\tsigned:0;\n" + "\tfield:unsigned char common_preempt_count;\toffset:3;\tsize:1;\tsigned:0;\n" + "\tfield:int common_pid;\toffset:4;\tsize:4;\tsigned:1;\n" + "\n" + "\tfield:int s4;\toffset:8;\tsize:4;\tsigned:1;\n" + "\tfield:unsigned int u4;\toffset:12;\tsize:4;\tsigned:0;\n" + "\tfield:long long s8;\toffset:16;\tsize:8;\tsigned:1;\n" + "\tfield:unsigned long long u8;\toffset:24;\tsize:8;\tsigned:0;\n" + "\n" + "print fmt: \"int=%d unsigned=%d unsigned int=%d long=%d unsigned long=%d long long=%d unsigned long long=%d s4=%d u4=%d s8=%d u8=%d\", " + "sizeof(int), sizeof(unsigned), sizeof(unsigned int), sizeof(long), sizeof(unsigned long), " + "sizeof(long long), sizeof(unsigned long long), sizeof(REC->s4), " + "sizeof(REC->u4), sizeof(REC->s8), sizeof(REC->u8))\n"; +static char sizeof_data[] = { +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + /* common type */ 23, 0x00, +#else + /* common type */ 0x00, 23 +#endif + /* common flags */ 0x00, + /* common_preempt_count */ 0x00, + /* common_pid */ 0x00, 0x00, 0x00, 0x00, + /* irq */ 0x00, 0x00, 0x00, 0x00, + + /* s4 */ 0x00, 0x00, 0x00, 0x00, + /* u4 */ 0x00, 0x00, 0x00, 0x00, + /* s8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* u8 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; +static void *sizeof_event_data = (void *)sizeof_data; + +DECL_CPUMASK_EVENT_DATA(full, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff); +#define CPUMASK_FULL "ARRAY[ff, ff, ff, ff, ff, ff, ff, ff]" +#define CPUMASK_FULL_FMT "cpumask=0-63" + +DECL_CPUMASK_EVENT_DATA(empty, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00); +#define CPUMASK_EMPTY "ARRAY[00, 00, 00, 00, 00, 00, 00, 00]" +#define CPUMASK_EMPTY_FMT "cpumask=" + +DECL_CPUMASK_EVENT_DATA(half, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55); +#define CPUMASK_HALF "ARRAY[55, 55, 55, 55, 55, 55, 55, 55]" +#define CPUMASK_HALF_FMT "cpumask=0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,34,36,38,40,42,44,46,48,50,52,54,56,58,60,62" + +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +DECL_CPUMASK_EVENT_DATA(bytep1, 0x01, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00); +#define CPUMASK_BYTEP1 "ARRAY[01, 80, 00, 00, 00, 00, 00, 00]" +#define CPUMASK_BYTEP1_FMT "cpumask=0,15" + +DECL_CPUMASK_EVENT_DATA(bytep2, 0x01, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00); +#define CPUMASK_BYTEP2 "ARRAY[01, 00, 80, 00, 00, 00, 00, 00]" +#define CPUMASK_BYTEP2_FMT "cpumask=0,23" + +DECL_CPUMASK_EVENT_DATA(bytepn, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80); +#define CPUMASK_BYTEPN "ARRAY[01, 00, 00, 00, 00, 00, 00, 80]" +#define CPUMASK_BYTEPN_FMT "cpumask=0,63" + +#else + +DECL_CPUMASK_EVENT_DATA(bytep1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x01); +#define CPUMASK_BYTEP1 "ARRAY[00, 00, 00, 00, 00, 00, 80, 01]" +#define CPUMASK_BYTEP1_FMT "cpumask=0,15" + +DECL_CPUMASK_EVENT_DATA(bytep2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x01); +#define CPUMASK_BYTEP2 "ARRAY[00, 00, 00, 00, 00, 80, 00, 01]" +#define CPUMASK_BYTEP2_FMT "cpumask=0,23" + +DECL_CPUMASK_EVENT_DATA(bytepn, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01); +#define CPUMASK_BYTEPN "ARRAY[80, 00, 00, 00, 00, 00, 80, 01]" +#define CPUMASK_BYTEPN_FMT "cpumask=0,63" +#endif + +static struct tep_handle *test_tep; +static struct trace_seq *test_seq; +static struct trace_seq seq_storage; + +static void parse_dyn_str(const char *dyn_str, void *data, int size) +{ + struct tep_format_field *field; + struct tep_event *event; + struct tep_record record; + + record.data = data; + record.size = size; + + CU_TEST(tep_parse_format(test_tep, &event, + dyn_str, strlen(dyn_str), + DYN_STR_EVENT_SYSTEM) == TEP_ERRNO__SUCCESS); + + field = tep_find_any_field(event, DYN_STR_FIELD); + CU_TEST(field != NULL); + trace_seq_reset(test_seq); + tep_print_field_content(test_seq, data, size, field); + CU_TEST(strcmp(test_seq->buffer, DYN_STRING) == 0); + + trace_seq_reset(test_seq); + tep_print_event(test_tep, test_seq, &record, "%s", TEP_PRINT_INFO); + trace_seq_do_printf(test_seq); + CU_TEST(strcmp(test_seq->buffer, DYN_STRING_FMT) == 0); +} + +static void test_parse_dyn_str_event(void) +{ + parse_dyn_str(dyn_str_event, dyn_str_event_data, sizeof(dyn_str_data)); +} + +static void test_parse_dyn_str_old_event(void) +{ + parse_dyn_str(dyn_str_old_event, dyn_str_old_event_data, sizeof(dyn_str_old_data)); +} + +static void parse_cpumask(const char *format, void *data, int size, + const char* expected_raw, const char* expected) +{ + struct tep_format_field *field; + struct tep_event *event; + struct tep_record record; + + record.data = data; + record.size = size; + + CU_TEST(tep_parse_format(test_tep, &event, + format, strlen(format), + CPUMASK_EVENT_SYSTEM) == TEP_ERRNO__SUCCESS); + + field = tep_find_any_field(event, CPUMASK_EVENT_FIELD); + CU_TEST(field != NULL); + + trace_seq_reset(test_seq); + tep_print_field_content(test_seq, data, size, field); + CU_TEST(strcmp(test_seq->buffer, expected_raw) == 0); + + trace_seq_reset(test_seq); + tep_print_event(test_tep, test_seq, &record, "%s", TEP_PRINT_INFO); + trace_seq_do_printf(test_seq); + CU_TEST(strcmp(test_seq->buffer, expected) == 0); +} + +static void test_parse_cpumask_full(void) +{ + parse_cpumask(cpumask_event_format, + cpumask_full_event_data, sizeof(cpumask_full_event_data), + CPUMASK_FULL, CPUMASK_FULL_FMT); +} + +static void test_parse_cpumask_empty(void) +{ + parse_cpumask(cpumask_event_format, + cpumask_empty_event_data, sizeof(cpumask_empty_event_data), + CPUMASK_EMPTY, CPUMASK_EMPTY_FMT); +} + +static void test_parse_cpumask_half(void) +{ + parse_cpumask(cpumask_event_format, + cpumask_half_event_data, sizeof(cpumask_half_event_data), + CPUMASK_HALF, CPUMASK_HALF_FMT); +} + +static void test_parse_cpumask_bytep1(void) +{ + parse_cpumask(cpumask_event_format, + cpumask_bytep1_event_data, sizeof(cpumask_bytep1_event_data), + CPUMASK_BYTEP1, CPUMASK_BYTEP1_FMT); +} + +static void test_parse_cpumask_bytep2(void) +{ + parse_cpumask(cpumask_event_format, + cpumask_bytep2_event_data, sizeof(cpumask_bytep2_event_data), + CPUMASK_BYTEP2, CPUMASK_BYTEP2_FMT); +} + +static void test_parse_cpumask_bytepn(void) +{ + parse_cpumask(cpumask_event_format, + cpumask_bytepn_event_data, sizeof(cpumask_bytepn_event_data), + CPUMASK_BYTEPN, CPUMASK_BYTEPN_FMT); +} + +static void test_parse_sizeof(int long_size, int value, const char *system, + const char *test_str) +{ + struct tep_event *event; + struct tep_record record; + char *sizeof_event; + char *p; + + tep_set_long_size(test_tep, long_size); + + record.data = sizeof_event_data; + record.size = sizeof(sizeof_data); + + sizeof_event = strdup(size_of_event); + CU_TEST(sizeof_event != NULL); + + /* Set a new id */ + p = strstr(sizeof_event, "ID: 2"); + p[5] = '0' + value; + + /* Handles endianess */ + *(unsigned short *)sizeof_data = 20 + value; + + CU_TEST(tep_parse_format(test_tep, &event, sizeof_event, + strlen(sizeof_event), + system) == TEP_ERRNO__SUCCESS); + + trace_seq_reset(test_seq); + tep_print_event(test_tep, test_seq, &record, "%s", TEP_PRINT_INFO); + trace_seq_do_printf(test_seq); + CU_TEST(strcmp(test_seq->buffer, test_str) == 0); + + free(sizeof_event); +} + +static void test_parse_sizeof8(void) +{ + test_parse_sizeof(8, 3, "sizeof8", SIZEOF_LONG8_FMT); +} + +static void test_parse_sizeof4(void) +{ + test_parse_sizeof(4, 4, "sizeof4", SIZEOF_LONG4_FMT); +} + +static void test_parse_sizeof_undef(void) +{ + test_parse_sizeof(0, 5, "sizeof_undef", SIZEOF_LONG0_FMT); +} + +static int test_suite_destroy(void) +{ + tep_free(test_tep); + trace_seq_destroy(test_seq); + return 0; +} + +static int test_suite_init(void) +{ + test_seq = &seq_storage; + trace_seq_init(test_seq); + test_tep = tep_alloc(); + if (!test_tep) + return 1; + return 0; +} + +void test_traceevent_lib(void) +{ + CU_pSuite suite = NULL; + + suite = CU_add_suite(TRACEEVENT_SUITE, test_suite_init, test_suite_destroy); + if (suite == NULL) { + fprintf(stderr, "Suite \"%s\" cannot be ceated\n", TRACEEVENT_SUITE); + return; + } + CU_add_test(suite, "parse dynamic string event", + test_parse_dyn_str_event); + CU_add_test(suite, "parse old dynamic string event", + test_parse_dyn_str_old_event); + CU_add_test(suite, "parse full cpumask", + test_parse_cpumask_full); + CU_add_test(suite, "parse empty cpumask", + test_parse_cpumask_empty); + CU_add_test(suite, "parse half-filled cpumask", + test_parse_cpumask_half); + CU_add_test(suite, "parse cpumask spanning 2 bytes", + test_parse_cpumask_bytep1); + CU_add_test(suite, "parse cpumask spanning 3 bytes", + test_parse_cpumask_bytep2); + CU_add_test(suite, "parse cpumask spanning all bytes", + test_parse_cpumask_bytepn); + CU_add_test(suite, "parse sizeof() 8byte values", + test_parse_sizeof8); + CU_add_test(suite, "parse sizeof() 4byte values", + test_parse_sizeof4); + CU_add_test(suite, "parse sizeof() no long size defined", + test_parse_sizeof_undef); +} |