hyung-hwan/hio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

touched up test scripts. switched to the tap style testing

Browse Source
This commit is contained in:
hyung-hwan 2022-12-17 16:04:33 +00:00
parent ce3340d2fa
commit 4779344dd0
10 changed files with 166 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Makefile.in
View File

@ -164,9 +164,10 @@ am__DIST_COMMON = $(srcdir)/Dockerfile.in $(srcdir)/Makefile.in \
$(top_srcdir)/ac/ar-lib $(top_srcdir)/ac/compile \ $(top_srcdir)/ac/ar-lib $(top_srcdir)/ac/compile \
$(top_srcdir)/ac/config.guess $(top_srcdir)/ac/config.sub \ $(top_srcdir)/ac/config.guess $(top_srcdir)/ac/config.sub \
$(top_srcdir)/ac/install-sh $(top_srcdir)/ac/ltmain.sh \ $(top_srcdir)/ac/install-sh $(top_srcdir)/ac/ltmain.sh \
$(top_srcdir)/ac/missing $(top_srcdir)/pkgs/hio.spec.in \ $(top_srcdir)/ac/missing $(top_srcdir)/ac/tap-driver.sh \
ac/ar-lib ac/compile ac/config.guess ac/config.sub ac/depcomp \ $(top_srcdir)/pkgs/hio.spec.in ac/ar-lib ac/compile \
ac/install-sh ac/ltmain.sh ac/missing ac/config.guess ac/config.sub ac/install-sh ac/ltmain.sh \
ac/missing
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
distdir = $(PACKAGE)-$(VERSION) distdir = $(PACKAGE)-$(VERSION)
top_distdir = $(distdir) top_distdir = $(distdir)

2
configure vendored
View File

@ -4405,6 +4405,8 @@ unknown)
esac esac
# Check whether --enable-silent-rules was given. # Check whether --enable-silent-rules was given.
if test "${enable_silent_rules+set}" = set; then : if test "${enable_silent_rules+set}" = set; then :
enableval=$enable_silent_rules; enableval=$enable_silent_rules;

2
configure.ac
View File

@ -13,6 +13,8 @@ dnl initialize automake
AM_INIT_AUTOMAKE([-Wall -Werror subdir-objects foreign]) AM_INIT_AUTOMAKE([-Wall -Werror subdir-objects foreign])
AM_PROG_AR AM_PROG_AR
AC_REQUIRE_AUX_FILE([tap-driver.sh])
dnl enable silent rules if automake supports them. dnl enable silent rules if automake supports them.
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([no])]) m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([no])])
dnl m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])]) dnl m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])

10
t/Makefile.am
View File

@ -13,8 +13,7 @@ LDFLAGS_COMMON=-L$(abs_builddir)/../lib -L$(libdir)
## for more information. ## for more information.
LIBADD_COMMON = ../lib/libhio.la $(LIBM) LIBADD_COMMON = ../lib/libhio.la $(LIBM)
check_SCRIPTS = check_SCRIPTS = s-001.sh
##noinst_SCRIPTS = $(check_SCRIPTS)
EXTRA_DIST = $(check_SCRIPTS) EXTRA_DIST = $(check_SCRIPTS)
check_PROGRAMS = t-001 t-002 t-003 t-004 check_PROGRAMS = t-001 t-002 t-003 t-004
@ -43,6 +42,11 @@ t_004_CFLAGS = $(CFLAGS_COMMON)
t_004_LDFLAGS = $(LDFLAGS_COMMON) t_004_LDFLAGS = $(LDFLAGS_COMMON)
t_004_LDADD = $(LIBADD_COMMON) t_004_LDADD = $(LIBADD_COMMON)
LOG_DRIVER = env AM_TAP_AWK='$(AWK)' $(SHELL) $(top_srcdir)/ac/tap-driver.sh
TESTS = $(check_PROGRAMS) $(check_SCRIPTS) TESTS = $(check_PROGRAMS) $(check_SCRIPTS)
TEST_EXTENSIONS = .sh
SH_LOG_DRIVER = $(LOG_DRIVER)
SH_LOG_COMPILER = /bin/sh
##SH_LOG_DRIVER_FLAGS =
##AM_SH_LOG_DRIVER_FLAGS =

34
t/Makefile.in
View File

@ -89,7 +89,6 @@ build_triplet = @build@
host_triplet = @host@ host_triplet = @host@
check_PROGRAMS = t-001$(EXEEXT) t-002$(EXEEXT) t-003$(EXEEXT) \ check_PROGRAMS = t-001$(EXEEXT) t-002$(EXEEXT) t-003$(EXEEXT) \
t-004$(EXEEXT) t-004$(EXEEXT)
TESTS = $(check_PROGRAMS) $(am__EXEEXT_1)
subdir = t subdir = t
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_sign.m4 \ am__aclocal_m4_deps = $(top_srcdir)/m4/ax_check_sign.m4 \
@ -385,10 +384,7 @@ am__set_TESTS_bases = \
AM_TESTSUITE_SUMMARY_HEADER = ' for $(PACKAGE_STRING)' AM_TESTSUITE_SUMMARY_HEADER = ' for $(PACKAGE_STRING)'
RECHECK_LOGS = $(TEST_LOGS) RECHECK_LOGS = $(TEST_LOGS)
AM_RECURSIVE_TARGETS = check recheck AM_RECURSIVE_TARGETS = check recheck
am__EXEEXT_1 =
TEST_SUITE_LOG = test-suite.log TEST_SUITE_LOG = test-suite.log
TEST_EXTENSIONS = @EXEEXT@ .test
LOG_DRIVER = $(SHELL) $(top_srcdir)/ac/test-driver
LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS) LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS)
am__set_b = \ am__set_b = \
case '$@' in \ case '$@' in \
@ -402,12 +398,9 @@ am__set_b = \
esac esac
am__test_logs1 = $(TESTS:=.log) am__test_logs1 = $(TESTS:=.log)
am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log) am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
TEST_LOGS = $(am__test_logs2:.test.log=.log) TEST_LOGS = $(am__test_logs2:.sh.log=.log)
TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/ac/test-driver SH_LOG_COMPILE = $(SH_LOG_COMPILER) $(AM_SH_LOG_FLAGS) $(SH_LOG_FLAGS)
TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \ am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/ac/depcomp
$(TEST_LOG_FLAGS)
am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/ac/depcomp \
$(top_srcdir)/ac/test-driver
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@ ACLOCAL = @ACLOCAL@
ALL_STATIC_LIBS = @ALL_STATIC_LIBS@ ALL_STATIC_LIBS = @ALL_STATIC_LIBS@
@ -559,7 +552,7 @@ CPPFLAGS_COMMON = \
CFLAGS_COMMON = CFLAGS_COMMON =
LDFLAGS_COMMON = -L$(abs_builddir)/../lib -L$(libdir) LDFLAGS_COMMON = -L$(abs_builddir)/../lib -L$(libdir)
LIBADD_COMMON = ../lib/libhio.la $(LIBM) LIBADD_COMMON = ../lib/libhio.la $(LIBM)
check_SCRIPTS = check_SCRIPTS = s-001.sh
EXTRA_DIST = $(check_SCRIPTS) EXTRA_DIST = $(check_SCRIPTS)
t_001_SOURCES = t-001.c t.h t_001_SOURCES = t-001.c t.h
t_001_CPPFLAGS = $(CPPFLAGS_COMMON) t_001_CPPFLAGS = $(CPPFLAGS_COMMON)
@ -581,10 +574,15 @@ t_004_CPPFLAGS = $(CPPFLAGS_COMMON)
t_004_CFLAGS = $(CFLAGS_COMMON) t_004_CFLAGS = $(CFLAGS_COMMON)
t_004_LDFLAGS = $(LDFLAGS_COMMON) t_004_LDFLAGS = $(LDFLAGS_COMMON)
t_004_LDADD = $(LIBADD_COMMON) t_004_LDADD = $(LIBADD_COMMON)
LOG_DRIVER = env AM_TAP_AWK='$(AWK)' $(SHELL) $(top_srcdir)/ac/tap-driver.sh
TESTS = $(check_PROGRAMS) $(check_SCRIPTS)
TEST_EXTENSIONS = .sh
SH_LOG_DRIVER = $(LOG_DRIVER)
SH_LOG_COMPILER = /bin/sh
all: all-am all: all-am
.SUFFIXES: .SUFFIXES:
.SUFFIXES: .c .lo .log .o .obj .test .test$(EXEEXT) .trs .SUFFIXES: .c .lo .log .o .obj .sh .sh$(EXEEXT) .trs
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) $(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \ @for dep in $?; do \
case '$(am__configure_deps)' in \ case '$(am__configure_deps)' in \
@ -964,19 +962,19 @@ t-004.log: t-004$(EXEEXT)
--log-file $$b.log --trs-file $$b.trs \ --log-file $$b.log --trs-file $$b.trs \
$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \ $(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
"$$tst" $(AM_TESTS_FD_REDIRECT) "$$tst" $(AM_TESTS_FD_REDIRECT)
.test.log: .sh.log:
@p='$<'; \ @p='$<'; \
$(am__set_b); \ $(am__set_b); \
$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \ $(am__check_pre) $(SH_LOG_DRIVER) --test-name "$$f" \
--log-file $$b.log --trs-file $$b.trs \ --log-file $$b.log --trs-file $$b.trs \
$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \ $(am__common_driver_flags) $(AM_SH_LOG_DRIVER_FLAGS) $(SH_LOG_DRIVER_FLAGS) -- $(SH_LOG_COMPILE) \
"$$tst" $(AM_TESTS_FD_REDIRECT) "$$tst" $(AM_TESTS_FD_REDIRECT)
@am__EXEEXT_TRUE@.test$(EXEEXT).log: @am__EXEEXT_TRUE@.sh$(EXEEXT).log:
@am__EXEEXT_TRUE@ @p='$<'; \ @am__EXEEXT_TRUE@ @p='$<'; \
@am__EXEEXT_TRUE@ $(am__set_b); \ @am__EXEEXT_TRUE@ $(am__set_b); \
@am__EXEEXT_TRUE@ $(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \ @am__EXEEXT_TRUE@ $(am__check_pre) $(SH_LOG_DRIVER) --test-name "$$f" \
@am__EXEEXT_TRUE@ --log-file $$b.log --trs-file $$b.trs \ @am__EXEEXT_TRUE@ --log-file $$b.log --trs-file $$b.trs \
@am__EXEEXT_TRUE@ $(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \ @am__EXEEXT_TRUE@ $(am__common_driver_flags) $(AM_SH_LOG_DRIVER_FLAGS) $(SH_LOG_DRIVER_FLAGS) -- $(SH_LOG_COMPILE) \
@am__EXEEXT_TRUE@ "$$tst" $(AM_TESTS_FD_REDIRECT) @am__EXEEXT_TRUE@ "$$tst" $(AM_TESTS_FD_REDIRECT)
distdir: $(BUILT_SOURCES) distdir: $(BUILT_SOURCES)

73
t/t-001.c
View File

@ -2,10 +2,12 @@
#include <hio-utl.h> #include <hio-utl.h>
#include <stdio.h> #include <stdio.h>
#include "t.h" #include "tap.h"
int main () int main ()
{ {
no_plan ();
{ {
union { union {
hio_uint16_t u16; hio_uint16_t u16;
@ -19,16 +21,16 @@ int main ()
printf("htole16(x.u16) = 0x%04x\n", hio_htole16(x.u16)); printf("htole16(x.u16) = 0x%04x\n", hio_htole16(x.u16));
printf("htobe16(x.u16) = 0x%04x\n", hio_htobe16(x.u16)); printf("htobe16(x.u16) = 0x%04x\n", hio_htobe16(x.u16));
T_ASSERT1 (x.u16 != hio_htole16(x.u16) || x.u16 != hio_htobe16(x.u16), "u16 endian conversion #0"); OK (x.u16 != hio_htole16(x.u16) || x.u16 != hio_htobe16(x.u16), "u16 endian conversion #0");
T_ASSERT1 (x.u16 == hio_le16toh(hio_htole16(x.u16)), "u16 endian conversion #1"); OK (x.u16 == hio_le16toh(hio_htole16(x.u16)), "u16 endian conversion #1");
T_ASSERT1 (x.u16 == hio_be16toh(hio_htobe16(x.u16)), "u16 endian conversion #2"); OK (x.u16 == hio_be16toh(hio_htobe16(x.u16)), "u16 endian conversion #2");
T_ASSERT1 (x.u16 == hio_ntoh16(hio_hton16(x.u16)), "u16 endian conversion #3"); OK (x.u16 == hio_ntoh16(hio_hton16(x.u16)), "u16 endian conversion #3");
#define X_CONST (0x1122) #define X_CONST (0x1122)
T_ASSERT1 (X_CONST != HIO_CONST_HTOLE16(X_CONST) || X_CONST != HIO_CONST_HTOBE16(X_CONST), "u16 constant endian conversion #0"); OK (X_CONST != HIO_CONST_HTOLE16(X_CONST) || X_CONST != HIO_CONST_HTOBE16(X_CONST), "u16 constant endian conversion #0");
T_ASSERT1 (X_CONST == HIO_CONST_LE16TOH(HIO_CONST_HTOLE16(X_CONST)), "u16 constant endian conversion #1"); OK (X_CONST == HIO_CONST_LE16TOH(HIO_CONST_HTOLE16(X_CONST)), "u16 constant endian conversion #1");
T_ASSERT1 (X_CONST == HIO_CONST_BE16TOH(HIO_CONST_HTOBE16(X_CONST)), "u16 constant endian conversion #2"); OK (X_CONST == HIO_CONST_BE16TOH(HIO_CONST_HTOBE16(X_CONST)), "u16 constant endian conversion #2");
T_ASSERT1 (X_CONST == HIO_CONST_NTOH16(HIO_CONST_HTON16(X_CONST)), "u16 constant endian conversion #3"); OK (X_CONST == HIO_CONST_NTOH16(HIO_CONST_HTON16(X_CONST)), "u16 constant endian conversion #3");
#undef X_CONST #undef X_CONST
} }
@ -48,16 +50,16 @@ int main ()
printf("htole32(x.u32) = 0x%08x\n", (unsigned int)hio_htole32(x.u32)); printf("htole32(x.u32) = 0x%08x\n", (unsigned int)hio_htole32(x.u32));
printf("htobe32(x.u32) = 0x%08x\n", (unsigned int)hio_htobe32(x.u32)); printf("htobe32(x.u32) = 0x%08x\n", (unsigned int)hio_htobe32(x.u32));
T_ASSERT1 (x.u32 != hio_htole32(x.u32) || x.u32 != hio_htobe32(x.u32), "u32 endian conversion #0"); OK (x.u32 != hio_htole32(x.u32) || x.u32 != hio_htobe32(x.u32), "u32 endian conversion #0");
T_ASSERT1 (x.u32 == hio_le32toh(hio_htole32(x.u32)), "u32 endian conversion #1"); OK (x.u32 == hio_le32toh(hio_htole32(x.u32)), "u32 endian conversion #1");
T_ASSERT1 (x.u32 == hio_be32toh(hio_htobe32(x.u32)), "u32 endian conversion #2"); OK (x.u32 == hio_be32toh(hio_htobe32(x.u32)), "u32 endian conversion #2");
T_ASSERT1 (x.u32 == hio_ntoh32(hio_hton32(x.u32)), "u32 endian conversion #3"); OK (x.u32 == hio_ntoh32(hio_hton32(x.u32)), "u32 endian conversion #3");
#define X_CONST (0x11223344) #define X_CONST (0x11223344)
T_ASSERT1 (X_CONST != HIO_CONST_HTOLE32(X_CONST) || X_CONST != HIO_CONST_HTOBE32(X_CONST), "u32 constant endian conversion #0"); OK (X_CONST != HIO_CONST_HTOLE32(X_CONST) || X_CONST != HIO_CONST_HTOBE32(X_CONST), "u32 constant endian conversion #0");
T_ASSERT1 (X_CONST == HIO_CONST_LE32TOH(HIO_CONST_HTOLE32(X_CONST)), "u32 constant endian conversion #1"); OK (X_CONST == HIO_CONST_LE32TOH(HIO_CONST_HTOLE32(X_CONST)), "u32 constant endian conversion #1");
T_ASSERT1 (X_CONST == HIO_CONST_BE32TOH(HIO_CONST_HTOBE32(X_CONST)), "u32 constant endian conversion #2"); OK (X_CONST == HIO_CONST_BE32TOH(HIO_CONST_HTOBE32(X_CONST)), "u32 constant endian conversion #2");
T_ASSERT1 (X_CONST == HIO_CONST_NTOH32(HIO_CONST_HTON32(X_CONST)), "u32 constant endian conversion #3"); OK (X_CONST == HIO_CONST_NTOH32(HIO_CONST_HTON32(X_CONST)), "u32 constant endian conversion #3");
#undef X_CONST #undef X_CONST
} }
@ -81,16 +83,16 @@ int main ()
printf("htole64(x.u64) = 0x%016llx\n", (unsigned long long)hio_htole64(x.u64)); printf("htole64(x.u64) = 0x%016llx\n", (unsigned long long)hio_htole64(x.u64));
printf("htobe64(x.u64) = 0x%016llx\n", (unsigned long long)hio_htobe64(x.u64)); printf("htobe64(x.u64) = 0x%016llx\n", (unsigned long long)hio_htobe64(x.u64));
T_ASSERT1 (x.u64 != hio_htole64(x.u64) || x.u64 != hio_htobe64(x.u64), "u64 endian conversion #0"); OK (x.u64 != hio_htole64(x.u64) || x.u64 != hio_htobe64(x.u64), "u64 endian conversion #0");
T_ASSERT1 (x.u64 == hio_le64toh(hio_htole64(x.u64)), "u64 endian conversion #1"); OK (x.u64 == hio_le64toh(hio_htole64(x.u64)), "u64 endian conversion #1");
T_ASSERT1 (x.u64 == hio_be64toh(hio_htobe64(x.u64)), "u64 endian conversion #2"); OK (x.u64 == hio_be64toh(hio_htobe64(x.u64)), "u64 endian conversion #2");
T_ASSERT1 (x.u64 == hio_ntoh64(hio_hton64(x.u64)), "u64 endian conversion #3"); OK (x.u64 == hio_ntoh64(hio_hton64(x.u64)), "u64 endian conversion #3");
#define X_CONST (((hio_uint64_t)0x11223344 << 32) | (hio_uint64_t)0x55667788) #define X_CONST (((hio_uint64_t)0x11223344 << 32) | (hio_uint64_t)0x55667788)
T_ASSERT1 (X_CONST != HIO_CONST_HTOLE64(X_CONST) || X_CONST != HIO_CONST_HTOBE64(X_CONST), "u64 constant endian conversion #0"); OK (X_CONST != HIO_CONST_HTOLE64(X_CONST) || X_CONST != HIO_CONST_HTOBE64(X_CONST), "u64 constant endian conversion #0");
T_ASSERT1 (X_CONST == HIO_CONST_LE64TOH(HIO_CONST_HTOLE64(X_CONST)), "u64 constant endian conversion #1"); OK (X_CONST == HIO_CONST_LE64TOH(HIO_CONST_HTOLE64(X_CONST)), "u64 constant endian conversion #1");
T_ASSERT1 (X_CONST == HIO_CONST_BE64TOH(HIO_CONST_HTOBE64(X_CONST)), "u64 constant endian conversion #2"); OK (X_CONST == HIO_CONST_BE64TOH(HIO_CONST_HTOBE64(X_CONST)), "u64 constant endian conversion #2");
T_ASSERT1 (X_CONST == HIO_CONST_NTOH64(HIO_CONST_HTON64(X_CONST)), "u64 constant endian conversion #3"); OK (X_CONST == HIO_CONST_NTOH64(HIO_CONST_HTON64(X_CONST)), "u64 constant endian conversion #3");
#undef X_CONST #undef X_CONST
} }
#endif #endif
@ -128,22 +130,19 @@ int main ()
tmp = hio_htobe128(x.u128); tmp = hio_htobe128(x.u128);
printf("htobe128(tmp) = 0x%016llx%016llx\n", (unsigned long long)(hio_uint64_t)(tmp >> 64), (unsigned long long)(hio_uint64_t)(tmp >> 0)); printf("htobe128(tmp) = 0x%016llx%016llx\n", (unsigned long long)(hio_uint64_t)(tmp >> 64), (unsigned long long)(hio_uint64_t)(tmp >> 0));
T_ASSERT1 (x.u128 != hio_htole128(x.u128) || x.u128 != hio_htobe128(x.u128), "u128 endian conversion #0"); OK (x.u128 != hio_htole128(x.u128) || x.u128 != hio_htobe128(x.u128), "u128 endian conversion #0");
T_ASSERT1 (x.u128 == hio_le128toh(hio_htole128(x.u128)), "u128 endian conversion #1"); OK (x.u128 == hio_le128toh(hio_htole128(x.u128)), "u128 endian conversion #1");
T_ASSERT1 (x.u128 == hio_be128toh(hio_htobe128(x.u128)), "u128 endian conversion #2"); OK (x.u128 == hio_be128toh(hio_htobe128(x.u128)), "u128 endian conversion #2");
T_ASSERT1 (x.u128 == hio_ntoh128(hio_hton128(x.u128)), "u128 endian conversion #3"); OK (x.u128 == hio_ntoh128(hio_hton128(x.u128)), "u128 endian conversion #3");
#define X_CONST (((hio_uint128_t)0x11223344 << 96) | ((hio_uint128_t)0x55667788 << 64) | ((hio_uint128_t)0x99aabbcc << 32) | ((hio_uint128_t)0xddeefffa)) #define X_CONST (((hio_uint128_t)0x11223344 << 96) | ((hio_uint128_t)0x55667788 << 64) | ((hio_uint128_t)0x99aabbcc << 32) | ((hio_uint128_t)0xddeefffa))
T_ASSERT1 (X_CONST != HIO_CONST_HTOLE128(X_CONST) || X_CONST != HIO_CONST_HTOBE128(X_CONST), "u128 constant endian conversion #0"); OK (X_CONST != HIO_CONST_HTOLE128(X_CONST) || X_CONST != HIO_CONST_HTOBE128(X_CONST), "u128 constant endian conversion #0");
T_ASSERT1 (X_CONST == HIO_CONST_LE128TOH(HIO_CONST_HTOLE128(X_CONST)), "u128 constant endian conversion #1"); OK (X_CONST == HIO_CONST_LE128TOH(HIO_CONST_HTOLE128(X_CONST)), "u128 constant endian conversion #1");
T_ASSERT1 (X_CONST == HIO_CONST_BE128TOH(HIO_CONST_HTOBE128(X_CONST)), "u128 constant endian conversion #2"); OK (X_CONST == HIO_CONST_BE128TOH(HIO_CONST_HTOBE128(X_CONST)), "u128 constant endian conversion #2");
T_ASSERT1 (X_CONST == HIO_CONST_NTOH128(HIO_CONST_HTON128(X_CONST)), "u128 constant endian conversion #3"); OK (X_CONST == HIO_CONST_NTOH128(HIO_CONST_HTON128(X_CONST)), "u128 constant endian conversion #3");
#undef X_CONST #undef X_CONST
} }
#endif #endif
return 0; return exit_status();
oops:
return -1;
} }

40
t/t-002.c
View File

@ -1,53 +1,55 @@
#include <hio-utl.h> #include <hio-utl.h>
#include <stdio.h> #include <stdio.h>
#include "t.h" #include "tap.h"
int main () int main ()
{ {
no_plan ();
{ {
int is_sober; int is_sober;
const hio_bch_t* endptr; const hio_bch_t* endptr;
hio_intmax_t v; hio_intmax_t v;
v = hio_bchars_to_intmax("10 ", 3, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(0,0,0,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10 ", 3, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(0,0,0,10), &endptr, &is_sober);
T_ASSERT1 (v == 10 && *endptr == ' ' && is_sober == 1, "space after digits without rtrim"); OK (v == 10 && *endptr == ' ' && is_sober == 1, "space after digits without rtrim");
v = hio_bchars_to_intmax("10 ", 3, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(0,0,1,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10 ", 3, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(0,0,1,10), &endptr, &is_sober);
T_ASSERT1 (v == 10 && *endptr == '\0' && is_sober == 1, "space after digits with rtrim"); OK (v == 10 && *endptr == '\0' && is_sober == 1, "space after digits with rtrim");
v = hio_bchars_to_intmax("10E", 3, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(0,0,1,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10E", 3, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(0,0,1,10), &endptr, &is_sober);
T_ASSERT1 (v == 10 && *endptr == 'E' && is_sober == 1, "number ending with E without the E option "); OK (v == 10 && *endptr == 'E' && is_sober == 1, "number ending with E without the E option ");
v = hio_bchars_to_intmax("10E", 3, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10E", 3, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober);
T_ASSERT1 (v == 10 && *endptr == '\0' && is_sober == 1, "integer in E notation"); OK (v == 10 && *endptr == '\0' && is_sober == 1, "integer in E notation");
v = hio_bchars_to_intmax("10E+0", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10E+0", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober);
T_ASSERT1 (v == 10 && *endptr == '\0' && is_sober == 1, "integer in E notation"); OK (v == 10 && *endptr == '\0' && is_sober == 1, "integer in E notation");
v = hio_bchars_to_intmax("10E+1", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10E+1", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober);
T_ASSERT1 (v == 100 && *endptr == '\0' && is_sober == 1, "integer in E notation"); OK (v == 100 && *endptr == '\0' && is_sober == 1, "integer in E notation");
v = hio_bchars_to_intmax("10E+2", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10E+2", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober);
T_ASSERT1 (v == 1000 && *endptr == '\0' && is_sober == 1, "integer in E notation"); OK (v == 1000 && *endptr == '\0' && is_sober == 1, "integer in E notation");
v = hio_bchars_to_intmax("10E3", 4, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10E3", 4, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober);
T_ASSERT1 (v == 10000 && *endptr == '\0' && is_sober == 1, "integer in E notation"); OK (v == 10000 && *endptr == '\0' && is_sober == 1, "integer in E notation");
v = hio_bchars_to_intmax("10E-", 4, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10E-", 4, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober);
T_ASSERT1 (v == 10 && *endptr == '\0' && is_sober == 1, "integer in E notation"); OK (v == 10 && *endptr == '\0' && is_sober == 1, "integer in E notation");
v = hio_bchars_to_intmax("10E-0", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10E-0", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober);
T_ASSERT1 (v == 10 && *endptr == '\0' && is_sober == 1, "integer in E notation"); OK (v == 10 && *endptr == '\0' && is_sober == 1, "integer in E notation");
v = hio_bchars_to_intmax("10E-1", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10E-1", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober);
T_ASSERT1 (v == 1 && *endptr == '\0' && is_sober == 1, "integer in E notation"); OK (v == 1 && *endptr == '\0' && is_sober == 1, "integer in E notation");
v = hio_bchars_to_intmax("10E-2", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober); v = hio_bchars_to_intmax("10E-2", 5, HIO_BCHARS_TO_INTMAX_MAKE_OPTION(1,0,1,10), &endptr, &is_sober);
T_ASSERT1 (v == 0 && *endptr == '\0' && is_sober == 1, "integer in E notation"); OK (v == 0 && *endptr == '\0' && is_sober == 1, "integer in E notation");
} }
{ {
@ -56,21 +58,19 @@ int main ()
hio_uch_t uc; hio_uch_t uc;
x = hio_uc_to_utf8(0x2665, tmp, HIO_COUNTOF(tmp)); x = hio_uc_to_utf8(0x2665, tmp, HIO_COUNTOF(tmp));
T_ASSERT1 (x == 3 && (hio_uint8_t)tmp[0] == 0xE2 && (hio_uint8_t)tmp[1] == 0x99 && (hio_uint8_t)tmp[2] == 0xA5, "unicode to utf8 conversion"); OK (x == 3 && (hio_uint8_t)tmp[0] == 0xE2 && (hio_uint8_t)tmp[1] == 0x99 && (hio_uint8_t)tmp[2] == 0xA5, "unicode to utf8 conversion");
x = hio_utf8_to_uc(tmp, x, &uc); x = hio_utf8_to_uc(tmp, x, &uc);
T_ASSERT1 (x == 3 && uc == 0x2665, "utf8 to unicode conversion"); OK (x == 3 && uc == 0x2665, "utf8 to unicode conversion");
#if (HIO_SIZEOF_UCH_T > 2) #if (HIO_SIZEOF_UCH_T > 2)
x = hio_uc_to_utf8(0x1F3E9, tmp, HIO_COUNTOF(tmp)); x = hio_uc_to_utf8(0x1F3E9, tmp, HIO_COUNTOF(tmp));
T_ASSERT1 (x == 4 && (hio_uint8_t)tmp[0] == 0xF0 && (hio_uint8_t)tmp[1] == 0x9F && (hio_uint8_t)tmp[2] == 0x8F && (hio_uint8_t)tmp[3] == 0xA9, "unicode to utf8 conversion"); OK (x == 4 && (hio_uint8_t)tmp[0] == 0xF0 && (hio_uint8_t)tmp[1] == 0x9F && (hio_uint8_t)tmp[2] == 0x8F && (hio_uint8_t)tmp[3] == 0xA9, "unicode to utf8 conversion");
x = hio_utf8_to_uc(tmp, x, &uc); x = hio_utf8_to_uc(tmp, x, &uc);
T_ASSERT1 (x == 4 && uc == 0x1F3E9, "utf8 to unicode conversion"); OK (x == 4 && uc == 0x1F3E9, "utf8 to unicode conversion");
#endif #endif
} }
return 0;
oops: return exit_status();
return -1;
} }

107
t/t-003.c
View File

@ -1,7 +1,7 @@
#include <hio-rad.h> #include <hio-rad.h>
#include <stdio.h> #include <stdio.h>
#include "t.h" #include "tap.h"
#include <sys/socket.h> #include <sys/socket.h>
@ -10,6 +10,8 @@
int main () int main ()
{ {
no_plan ();
{ {
hio_uint8_t buf[10240]; hio_uint8_t buf[10240];
hio_rad_hdr_t* hdr = (hio_rad_hdr_t*)buf; hio_rad_hdr_t* hdr = (hio_rad_hdr_t*)buf;
@ -53,10 +55,10 @@ int main ()
}; };
hio_rad_initialize (hdr, HIO_RAD_ACCESS_REQUEST, 255); hio_rad_initialize (hdr, HIO_RAD_ACCESS_REQUEST, 255);
T_ASSERT1 (hdr->code == HIO_RAD_ACCESS_REQUEST, "hdr->code not ok"); OK (hdr->code == HIO_RAD_ACCESS_REQUEST, "hdr->code not ok");
T_ASSERT1 (hdr->id == 255, "hdr->id not ok"); OK (hdr->id == 255, "hdr->id not ok");
exptotlen = HIO_SIZEOF(*hdr); exptotlen = HIO_SIZEOF(*hdr);
T_ASSERT1 (hdr->length == HIO_CONST_HTON16(HIO_SIZEOF(*hdr)), "hdr->length not ok"); OK (hdr->length == HIO_CONST_HTON16(HIO_SIZEOF(*hdr)), "hdr->length not ok");
for (i = 0; i < HIO_COUNTOF(data); i++) for (i = 0; i < HIO_COUNTOF(data); i++)
@ -68,25 +70,25 @@ int main ()
hio_rad_lxvsattr_hdr_t* lxvsattr; hio_rad_lxvsattr_hdr_t* lxvsattr;
vsattr = hio_rad_insert_vsattr(hdr, HIO_SIZEOF(buf), data[i].vendor, data[i].attrcode, data[i].ptr, data[i].len); vsattr = hio_rad_insert_vsattr(hdr, HIO_SIZEOF(buf), data[i].vendor, data[i].attrcode, data[i].ptr, data[i].len);
T_ASSERT1 (vsattr != HIO_NULL, "attribute insertion failure"); OK (vsattr != HIO_NULL, "attribute insertion failure");
T_ASSERT1 (hio_ntoh16(hdr->length) == exptotlen + vsattr->length, "hdr->length not ok after attribute insertion"); OK (hio_ntoh16(hdr->length) == exptotlen + vsattr->length, "hdr->length not ok after attribute insertion");
if (HIO_RAD_ATTR_IS_LONG_EXTENDED(vsattr->type)) if (HIO_RAD_ATTR_IS_LONG_EXTENDED(vsattr->type))
{ {
exptotlen += HIO_SIZEOF(*lxvsattr); exptotlen += HIO_SIZEOF(*lxvsattr);
lxvsattr = (hio_rad_lxvsattr_hdr_t*)vsattr; lxvsattr = (hio_rad_lxvsattr_hdr_t*)vsattr;
T_ASSERT1 (lxvsattr->length == HIO_SIZEOF(*lxvsattr) + data[i].len, "wrong attribute length"); OK (lxvsattr->length == HIO_SIZEOF(*lxvsattr) + data[i].len, "wrong attribute length");
} }
else if (HIO_RAD_ATTR_IS_SHORT_EXTENDED(vsattr->type)) else if (HIO_RAD_ATTR_IS_SHORT_EXTENDED(vsattr->type))
{ {
exptotlen += HIO_SIZEOF(*xvsattr); exptotlen += HIO_SIZEOF(*xvsattr);
xvsattr = (hio_rad_xvsattr_hdr_t*)vsattr; xvsattr = (hio_rad_xvsattr_hdr_t*)vsattr;
T_ASSERT1 (xvsattr->length == HIO_SIZEOF(*xvsattr) + data[i].len, "wrong attribute length"); OK (xvsattr->length == HIO_SIZEOF(*xvsattr) + data[i].len, "wrong attribute length");
} }
else else
{ {
exptotlen += HIO_SIZEOF(*vsattr); exptotlen += HIO_SIZEOF(*vsattr);
T_ASSERT1 (vsattr->length == HIO_SIZEOF(*vsattr) + data[i].len, "wrong attribute length"); OK (vsattr->length == HIO_SIZEOF(*vsattr) + data[i].len, "wrong attribute length");
} }
} }
else else
@ -96,30 +98,30 @@ int main ()
hio_rad_lxattr_hdr_t* lxattr; hio_rad_lxattr_hdr_t* lxattr;
attr = hio_rad_insert_attr(hdr, HIO_SIZEOF(buf), data[i].attrcode, data[i].ptr, data[i].len); attr = hio_rad_insert_attr(hdr, HIO_SIZEOF(buf), data[i].attrcode, data[i].ptr, data[i].len);
T_ASSERT1 (attr != HIO_NULL, "attribute insertion failure"); OK (attr != HIO_NULL, "attribute insertion failure");
T_ASSERT1 (hio_ntoh16(hdr->length) == exptotlen + attr->length, "hdr->length not ok after attribute insertion"); OK (hio_ntoh16(hdr->length) == exptotlen + attr->length, "hdr->length not ok after attribute insertion");
if (HIO_RAD_ATTR_IS_LONG_EXTENDED(attr->type)) if (HIO_RAD_ATTR_IS_LONG_EXTENDED(attr->type))
{ {
exptotlen += HIO_SIZEOF(*lxattr); exptotlen += HIO_SIZEOF(*lxattr);
lxattr = (hio_rad_lxattr_hdr_t*)attr; lxattr = (hio_rad_lxattr_hdr_t*)attr;
T_ASSERT1 (lxattr->length == HIO_SIZEOF(*lxattr) + data[i].len, "wrong attribute length"); OK (lxattr->length == HIO_SIZEOF(*lxattr) + data[i].len, "wrong attribute length");
} }
else if (HIO_RAD_ATTR_IS_SHORT_EXTENDED(attr->type)) else if (HIO_RAD_ATTR_IS_SHORT_EXTENDED(attr->type))
{ {
exptotlen += HIO_SIZEOF(*xattr); exptotlen += HIO_SIZEOF(*xattr);
xattr = (hio_rad_xattr_hdr_t*)attr; xattr = (hio_rad_xattr_hdr_t*)attr;
T_ASSERT1 (xattr->length == HIO_SIZEOF(*xattr) + data[i].len, "wrong attribute length"); OK (xattr->length == HIO_SIZEOF(*xattr) + data[i].len, "wrong attribute length");
} }
else else
{ {
exptotlen += HIO_SIZEOF(*attr); exptotlen += HIO_SIZEOF(*attr);
T_ASSERT1 (attr->length == HIO_SIZEOF(*attr) + data[i].len, "wrong attribute length"); OK (attr->length == HIO_SIZEOF(*attr) + data[i].len, "wrong attribute length");
} }
} }
T_ASSERT1 (hio_comp_bchars((hio_uint8_t*)hdr + hio_ntoh16(hdr->length) - data[i].len, data[i].len, data[i].ptr, data[i].len, 0) == 0, "wrong attribute value"); OK (hio_comp_bchars((hio_uint8_t*)hdr + hio_ntoh16(hdr->length) - data[i].len, data[i].len, data[i].ptr, data[i].len, 0) == 0, "wrong attribute value");
exptotlen += data[i].len; exptotlen += data[i].len;
T_ASSERT1 (hio_ntoh16(hdr->length) == exptotlen, "hdr->length not ok after attribute insertion"); OK (hio_ntoh16(hdr->length) == exptotlen, "hdr->length not ok after attribute insertion");
for (j = 0; j < HIO_COUNTOF(data); j++) for (j = 0; j < HIO_COUNTOF(data); j++)
{ {
@ -133,46 +135,46 @@ int main ()
void* val_ptr; void* val_ptr;
int val_len; int val_len;
T_ASSERT1 (vsattr != HIO_NULL, "find failure"); OK (vsattr != HIO_NULL, "find failure");
if (HIO_RAD_ATTR_IS_SHORT_EXTENDED(vsattr->type)) if (HIO_RAD_ATTR_IS_SHORT_EXTENDED(vsattr->type))
{ {
hio_rad_xvsattr_hdr_t* xvsattr = (hio_rad_xvsattr_hdr_t*)vsattr; hio_rad_xvsattr_hdr_t* xvsattr = (hio_rad_xvsattr_hdr_t*)vsattr;
T_ASSERT1 (hio_ntoh32(xvsattr->vendor) == data[j].vendor, "wrong vendor code"); OK (hio_ntoh32(xvsattr->vendor) == data[j].vendor, "wrong vendor code");
T_ASSERT1 (xvsattr->type == HIO_RAD_ATTR_CODE_HI(data[j].attrcode), "wrong attribute base"); OK (xvsattr->type == HIO_RAD_ATTR_CODE_HI(data[j].attrcode), "wrong attribute base");
T_ASSERT1 (xvsattr->length == HIO_SIZEOF(*xvsattr) + data[j].len, "wrong attribute length"); OK (xvsattr->length == HIO_SIZEOF(*xvsattr) + data[j].len, "wrong attribute length");
T_ASSERT1 (xvsattr->xvs.type == HIO_RAD_ATTR_CODE_LO(data[j].attrcode), "wrong vendor-specific attribute type"); OK (xvsattr->xvs.type == HIO_RAD_ATTR_CODE_LO(data[j].attrcode), "wrong vendor-specific attribute type");
T_ASSERT1 (xvsattr->xvs.length == HIO_SIZEOF(xvsattr->xvs) + data[j].len, "wrong attribute length"); OK (xvsattr->xvs.length == HIO_SIZEOF(xvsattr->xvs) + data[j].len, "wrong attribute length");
val_ptr = xvsattr + 1; val_ptr = xvsattr + 1;
val_len = xvsattr->xvs.length - HIO_SIZEOF(xvsattr->xvs); val_len = xvsattr->xvs.length - HIO_SIZEOF(xvsattr->xvs);
} }
else if (HIO_RAD_ATTR_IS_LONG_EXTENDED(vsattr->type)) else if (HIO_RAD_ATTR_IS_LONG_EXTENDED(vsattr->type))
{ {
hio_rad_lxvsattr_hdr_t* lxvsattr = (hio_rad_lxvsattr_hdr_t*)vsattr; hio_rad_lxvsattr_hdr_t* lxvsattr = (hio_rad_lxvsattr_hdr_t*)vsattr;
T_ASSERT1 (hio_ntoh32(lxvsattr->vendor) == data[j].vendor, "wrong vendor code"); OK (hio_ntoh32(lxvsattr->vendor) == data[j].vendor, "wrong vendor code");
T_ASSERT1 (lxvsattr->type == HIO_RAD_ATTR_CODE_HI(data[j].attrcode), "wrong attribute base"); OK (lxvsattr->type == HIO_RAD_ATTR_CODE_HI(data[j].attrcode), "wrong attribute base");
T_ASSERT1 (lxvsattr->length == HIO_SIZEOF(*lxvsattr) + data[j].len, "wrong attribute length"); OK (lxvsattr->length == HIO_SIZEOF(*lxvsattr) + data[j].len, "wrong attribute length");
T_ASSERT1 (lxvsattr->lxvs.type == HIO_RAD_ATTR_CODE_LO(data[j].attrcode), "wrong vendor-specific attribute type"); OK (lxvsattr->lxvs.type == HIO_RAD_ATTR_CODE_LO(data[j].attrcode), "wrong vendor-specific attribute type");
T_ASSERT1 (lxvsattr->lxvs.length == HIO_SIZEOF(lxvsattr->lxvs) + data[j].len, "wrong attribute length"); OK (lxvsattr->lxvs.length == HIO_SIZEOF(lxvsattr->lxvs) + data[j].len, "wrong attribute length");
val_ptr = lxvsattr + 1; val_ptr = lxvsattr + 1;
val_len = lxvsattr->lxvs.length - HIO_SIZEOF(lxvsattr->lxvs); val_len = lxvsattr->lxvs.length - HIO_SIZEOF(lxvsattr->lxvs);
} }
else else
{ {
T_ASSERT1 (hio_ntoh32(vsattr->vendor) == data[j].vendor, "wrong vendor code"); OK (hio_ntoh32(vsattr->vendor) == data[j].vendor, "wrong vendor code");
T_ASSERT1 (vsattr->type == HIO_RAD_ATTR_VENDOR_SPECIFIC, "wrong attribute type"); OK (vsattr->type == HIO_RAD_ATTR_VENDOR_SPECIFIC, "wrong attribute type");
T_ASSERT1 (vsattr->length == HIO_SIZEOF(*vsattr) + data[j].len, "wrong attribute length"); OK (vsattr->length == HIO_SIZEOF(*vsattr) + data[j].len, "wrong attribute length");
T_ASSERT1 (vsattr->vs.type == data[j].attrcode, "wrong vendor-specific attribute type"); OK (vsattr->vs.type == data[j].attrcode, "wrong vendor-specific attribute type");
T_ASSERT1 (vsattr->vs.length == HIO_SIZEOF(vsattr->vs) + data[j].len, "wrong attribute length"); OK (vsattr->vs.length == HIO_SIZEOF(vsattr->vs) + data[j].len, "wrong attribute length");
val_ptr = vsattr + 1; val_ptr = vsattr + 1;
val_len = vsattr->vs.length - HIO_SIZEOF(vsattr->vs); val_len = vsattr->vs.length - HIO_SIZEOF(vsattr->vs);
} }
T_ASSERT1 (hio_comp_bchars(val_ptr, val_len, data[j].ptr, data[j].len, 0) == 0, "wrong attribute value"); OK (hio_comp_bchars(val_ptr, val_len, data[j].ptr, data[j].len, 0) == 0, "wrong attribute value");
} }
else else
{ {
T_ASSERT1 (vsattr == HIO_NULL, "find failure"); OK (vsattr == HIO_NULL, "find failure");
} }
} }
else else
@ -184,39 +186,39 @@ int main ()
{ {
void* val_ptr; void* val_ptr;
int val_len; int val_len;
T_ASSERT1 (attr != HIO_NULL, "find failure"); OK (attr != HIO_NULL, "find failure");
if (HIO_RAD_ATTR_IS_SHORT_EXTENDED(attr->type)) if (HIO_RAD_ATTR_IS_SHORT_EXTENDED(attr->type))
{ {
hio_rad_xattr_hdr_t* xattr = (hio_rad_xattr_hdr_t*)attr; hio_rad_xattr_hdr_t* xattr = (hio_rad_xattr_hdr_t*)attr;
T_ASSERT1 (HIO_RAD_ATTR_CODE_HI(data[j].attrcode) == xattr->type, "wrong extended attribute base"); OK (HIO_RAD_ATTR_CODE_HI(data[j].attrcode) == xattr->type, "wrong extended attribute base");
T_ASSERT1 (HIO_RAD_ATTR_CODE_LO(data[j].attrcode) == xattr->xtype, "wrong extended attribute type"); OK (HIO_RAD_ATTR_CODE_LO(data[j].attrcode) == xattr->xtype, "wrong extended attribute type");
T_ASSERT1 (xattr->length == HIO_SIZEOF(*xattr) + data[j].len, "wrong attribute length"); OK (xattr->length == HIO_SIZEOF(*xattr) + data[j].len, "wrong attribute length");
val_ptr = xattr + 1; val_ptr = xattr + 1;
val_len = xattr->length - HIO_SIZEOF(*xattr); val_len = xattr->length - HIO_SIZEOF(*xattr);
} }
else if (HIO_RAD_ATTR_IS_LONG_EXTENDED(attr->type)) else if (HIO_RAD_ATTR_IS_LONG_EXTENDED(attr->type))
{ {
hio_rad_lxattr_hdr_t* lxattr = (hio_rad_lxattr_hdr_t*)attr; hio_rad_lxattr_hdr_t* lxattr = (hio_rad_lxattr_hdr_t*)attr;
T_ASSERT1 (HIO_RAD_ATTR_CODE_HI(data[j].attrcode) == lxattr->type, "wrong long extended attribute base"); OK (HIO_RAD_ATTR_CODE_HI(data[j].attrcode) == lxattr->type, "wrong long extended attribute base");
T_ASSERT1 (HIO_RAD_ATTR_CODE_LO(data[j].attrcode) == lxattr->xtype, "wrong long extended attribute type"); OK (HIO_RAD_ATTR_CODE_LO(data[j].attrcode) == lxattr->xtype, "wrong long extended attribute type");
T_ASSERT1 (lxattr->length == HIO_SIZEOF(*lxattr) + data[j].len, "wrong attribute length"); OK (lxattr->length == HIO_SIZEOF(*lxattr) + data[j].len, "wrong attribute length");
val_ptr = lxattr + 1; val_ptr = lxattr + 1;
val_len = lxattr->length - HIO_SIZEOF(*lxattr); val_len = lxattr->length - HIO_SIZEOF(*lxattr);
} }
else else
{ {
T_ASSERT1 (attr->type == data[j].attrcode, "wrong attribute type"); OK (attr->type == data[j].attrcode, "wrong attribute type");
T_ASSERT1 (attr->length == HIO_SIZEOF(*attr) + data[j].len, "wrong attribute length"); OK (attr->length == HIO_SIZEOF(*attr) + data[j].len, "wrong attribute length");
val_ptr = attr + 1; val_ptr = attr + 1;
val_len = attr->length - HIO_SIZEOF(*attr); val_len = attr->length - HIO_SIZEOF(*attr);
} }
T_ASSERT1 (hio_comp_bchars(val_ptr, val_len, data[j].ptr, data[j].len, 0) == 0, "wrong attribute value"); OK (hio_comp_bchars(val_ptr, val_len, data[j].ptr, data[j].len, 0) == 0, "wrong attribute value");
} }
else else
{ {
T_ASSERT1 (attr == HIO_NULL, "find failure"); OK (attr == HIO_NULL, "find failure");
} }
} }
} }
@ -227,7 +229,7 @@ int main ()
exptotlen -= HIO_SIZEOF(hio_rad_attr_hdr_t) + 8; /* the first User-Password in the data table */ exptotlen -= HIO_SIZEOF(hio_rad_attr_hdr_t) + 8; /* the first User-Password in the data table */
exptotlen -= HIO_SIZEOF(hio_rad_attr_hdr_t) + 8; /* the second User-Password in the data table */ exptotlen -= HIO_SIZEOF(hio_rad_attr_hdr_t) + 8; /* the second User-Password in the data table */
exptotlen += HIO_SIZEOF(hio_rad_attr_hdr_t) + HIO_RAD_USER_PASSWORD_TOTSIZE(18); exptotlen += HIO_SIZEOF(hio_rad_attr_hdr_t) + HIO_RAD_USER_PASSWORD_TOTSIZE(18);
T_ASSERT1 (hio_ntoh16(hdr->length) == exptotlen, "hdr->length not ok"); OK (hio_ntoh16(hdr->length) == exptotlen, "hdr->length not ok");
{ {
char tmp[1024]; char tmp[1024];
@ -238,12 +240,12 @@ int main ()
/* the following call must insert 5 attributes. it returns the pointer to the first attribute. */ /* the following call must insert 5 attributes. it returns the pointer to the first attribute. */
attr = hio_rad_insert_attr (hdr, HIO_SIZEOF(buf), HIO_RAD_ATTR_CODE_EXTENDED_6(10), tmp, 1024); attr = hio_rad_insert_attr (hdr, HIO_SIZEOF(buf), HIO_RAD_ATTR_CODE_EXTENDED_6(10), tmp, 1024);
T_ASSERT1 (attr != HIO_NULL, "long extended attribue insertion failure"); OK (attr != HIO_NULL, "long extended attribue insertion failure");
T_ASSERT1 (attr->type == HIO_RAD_ATTR_EXTENDED_6, "wrong extended attribute base"); OK (attr->type == HIO_RAD_ATTR_EXTENDED_6, "wrong extended attribute base");
lxattr = (hio_rad_lxattr_hdr_t*)attr; lxattr = (hio_rad_lxattr_hdr_t*)attr;
T_ASSERT1 (lxattr->xtype == 10, "wrong extended attribute type"); OK (lxattr->xtype == 10, "wrong extended attribute type");
T_ASSERT1 (lxattr->xflags == (1 << 7), "wrong long extended attribute flags"); OK (lxattr->xflags == (1 << 7), "wrong long extended attribute flags");
/* TODO: inspect 4 continuing attributes */ /* TODO: inspect 4 continuing attributes */
} }
@ -261,8 +263,5 @@ int main ()
#endif #endif
} }
return 0; return exit_status();
oops:
return -1;
} }

9
t/t-004.c
View File

@ -1,6 +1,6 @@
#include <hio-utl.h> #include <hio-utl.h>
#include <string.h> #include <string.h>
#include "t.h" #include "tap.h"
/* https://131002.net/siphash/siphash24.c */ /* https://131002.net/siphash/siphash24.c */
@ -78,6 +78,7 @@ static int test_sip_vectors()
hio_uint8_t in[MAXLEN], out[8], k[16]; hio_uint8_t in[MAXLEN], out[8], k[16];
int i; int i;
char tmp[64];
for( i = 0; i < 16; ++i ) k[i] = i; for( i = 0; i < 16; ++i ) k[i] = i;
@ -85,7 +86,8 @@ static int test_sip_vectors()
{ {
in[i] = i; in[i] = i;
hio_sip_hash_24(k, in, i, out); hio_sip_hash_24(k, in, i, out);
T_ASSERT1 (memcmp(out, vectors[i], 8) == 0, "test vector failure"); sprintf (tmp, "test vector %d", i);
OK (memcmp(out, vectors[i], 8) == 0, tmp);
} }
return 0; return 0;
@ -96,6 +98,7 @@ oops:
int main() int main()
{ {
no_plan ();
if (test_sip_vectors() <= -1) return -1; if (test_sip_vectors() <= -1) return -1;
return 0; return exit_status();
} }

35
t/tap.inc
View File

@ -1,31 +1,36 @@
tap_total=0 tap_total=0
function tap_end() tap_end()
{ {
printf "1..%d\n" tap_total printf "1..%d\n" $tap_total
} }
function tap_ok(msg) tap_ok()
{ {
tap_total++; local msg="$@"
printf "ok %d - %s\n" tap_total msg tap_total=$((tap_total + 1))
printf "ok %d - %s\n" $tap_total "$msg"
} }
function tap_fail(msg) tap_fail()
{ {
tap_total++; local msg="$@"
printf "not ok %d - %s\n" tap_total msg tap_total=$((tap_total + 1))
printf "not ok %d - %s\n" $tap_total "$msg"
} }
function tap_skip(msg) tap_skip()
{ {
tap_total++; local msg="$@"
printf "ok %d - # skip%s%s\n" tap_total (length(msg) > 0? " ": "") msg tap_total=$((tap_total + 1))
[ -n "$msg" ] && msg=" $msg"
printf "ok %d - # skip%s\n" $tap_total "$msg"
} }
function tap_ensure(a, b, desc, line) tap_ensure()
{ {
id = sprintf("%s[%d]", desc, line); local a="$1"
if (a != b) tap_fail (id); local b="$2"
else tap_ok (id); local desc="$3"
[ "x$a" = "x$b" ] && tap_ok "$desc" || tap_fail "$desc"
} }