static void test_1_01()
{
PAN_CHAR_T hostname[1000];
const string_t hid = pan_get_hid_();
{ for(size_t i = 0; i != STLSOFT_NUM_ELEMENTS(hostname); ++i)
{
::memset(&hostname[0], 0, sizeof(hostname));
const size_t len = pantheios::getHostName(&hostname[0], i);
if(len == i)
{
// The function did not have enough space to write in, so it
// will return the length passed to it ...
XTESTS_TEST_INTEGER_EQUAL(i, len);
// ... and will not have written anything to the file
XTESTS_TEST_STRING_EQUAL(PANTHEIOS_LITERAL_STRING(""), hostname);
}
else
{
// The function had enough space, so it will return the length
// of the intended hostname ...
XTESTS_TEST_INTEGER_EQUAL(hid.size(), len);
// ... and will have written the hostname
XTESTS_TEST_STRING_EQUAL(hid, hostname);
}
}}
}
static void test_1_06()
{
unsigned char bytes[] = { 255 };
char result[1001];
XTESTS_TEST_INTEGER_EQUAL(4u, b64_encode(&bytes[0], sizeof(bytes), NULL, 0));
XTESTS_TEST_INTEGER_EQUAL(4u, b64_encode(&bytes[0], sizeof(bytes), &result[0], STLSOFT_NUM_ELEMENTS(result)));
result[1000] = '\0';
XTESTS_TEST_MULTIBYTE_STRING_EQUAL_N("/w==", result, 4u);
}
static void test_1_07()
{
char bytes[] = "This is a test string";
char result[1001];
XTESTS_TEST_INTEGER_EQUAL(28u, b64_encode(&bytes[0], sizeof(bytes) - 1, NULL, 0));
XTESTS_TEST_INTEGER_EQUAL(28u, b64_encode(&bytes[0], sizeof(bytes) - 1, &result[0], STLSOFT_NUM_ELEMENTS(result)));
result[1000] = '\0';
XTESTS_TEST_MULTIBYTE_STRING_EQUAL_N("VGhpcyBpcyBhIHRlc3Qgc3RyaW5n", result, 28u);
}
static void test_1_08()
{
signed char bytes[] = { 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5, -6, -7 };
char result[1001];
XTESTS_TEST_INTEGER_EQUAL(20u, b64_encode(&bytes[0], sizeof(bytes), NULL, 0));
XTESTS_TEST_INTEGER_EQUAL(20u, b64_encode(&bytes[0], sizeof(bytes), &result[0], STLSOFT_NUM_ELEMENTS(result)));
result[1000] = '\0';
XTESTS_TEST_MULTIBYTE_STRING_EQUAL_N("BwYFBAMCAQD//v38+/r5", result, 20u);
}
static void test_1_1()
{
clasp_alias_t ALIASES[] =
{
CLASP_BIT_FLAG(NULL, "-f", 0x0001, ""),
CLASP_BIT_FLAG(NULL, "-g", 0x0002, ""),
CLASP_BIT_FLAG(NULL, "-h", 0x0004, ""),
CLASP_BIT_FLAG(NULL, "-i", 0x0006, ""),
CLASP_ALIAS_ARRAY_TERMINATOR
};
char* argv[] =
{
"arg0",
NULL
};
int const argc = STLSOFT_NUM_ELEMENTS(argv) - 1;
clasp_arguments_t const* args;
int const cr = clasp_parseArguments(0, argc, argv, NULL, NULL, &args);
if(0 != cr)
{
XTESTS_TEST_FAIL_WITH_QUALIFIER("failed to initialise CLASP", strerror(cr));
}
else
{
int const flagsAll = clasp_checkAllFlags(args, ALIASES, NULL);
int const flagsAny = clasp_checkAllMatchingFlags(args, ALIASES, ~(int)0, NULL);
int const flags0001 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0001, NULL);
int const flags0002 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0002, NULL);
int const flags0003 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0003, NULL);
int const flags0004 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0004, NULL);
int const flags0005 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0005, NULL);
int const flags0006 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0006, NULL);
int const flags0007 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0007, NULL);
int const flags0008 = clasp_checkAllMatchingFlags(args, ALIASES, 0x0008, NULL);
XTESTS_TEST_INTEGER_EQUAL(0x0000, flagsAll);
XTESTS_TEST_INTEGER_EQUAL(0x0000, flagsAny);
XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0001);
XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0002);
XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0003);
XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0004);
XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0005);
XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0006);
XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0007);
XTESTS_TEST_INTEGER_EQUAL(0x0000, flags0008);
clasp_releaseArguments(args);
}
}
static void test_comstl_C_BSTR_create_len_a(void)
{
char const alphabet[] = "abcdefghijklmnopqrstuvwxyz";
{ size_t i; for(i = 0; i != dimensionof(alphabet); ++i)
{
BSTR const s = comstl_C_BSTR_create_len_a(alphabet, i);
XTESTS_TEST_WIDE_STRING_EQUAL_N(m2w(alphabet), s, (int)i);
XTESTS_TEST_INTEGER_EQUAL(i, SysStringLen(s));
XTESTS_TEST_INTEGER_EQUAL(SysStringLen(s), comstl_C_BSTR_len(s));
comstl_C_BSTR_destroy(s);
}}
}
static void test_plain_characters()
{
static char const plain_characters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`~!@#$%^&*()-_=+[{]}|;:\",<.>/?";
// 1. Setup
pantheios::be::test::reset();
// 2. Create test data
{ for(size_t i = 0; STLSOFT_NUM_ELEMENTS(plain_characters) - 1 != i; ++i)
{
PAN_CHAR_T const ch = plain_characters[i];
pantheios::log_NOTICE(PSTR("{"), pantheios::stream_character(ch), PSTR("}"));
}}
// 3. Verification
pantheios::be::test::Results results = pantheios::be::test::results();
XTESTS_TEST(!results.empty());
XTESTS_TEST_INTEGER_EQUAL(STLSOFT_NUM_ELEMENTS(plain_characters) - 1, results.size());
{ for(size_t i = 0; STLSOFT_NUM_ELEMENTS(plain_characters) - 1 != i; ++i)
{
PAN_CHAR_T const ch = plain_characters[i];
PAN_CHAR_T sz[4] = { '{', ch, '}', '\0' };
XTESTS_TEST_STRING_EQUAL(sz, results[i].statement);
}}
}
static void test_21()
{
// 1. Setup
pantheios::be::test::reset();
// 2. Create test data
string_t msgEl1(256, '~');
string_t msgEl2(4096, '#');
pantheios::log(pantheios::informational, msgEl1, msgEl2);
// 3. Verification
pantheios::be::test::Results results = pantheios::be::test::results();
XTESTS_TEST_INTEGER_EQUAL(1u, results.size());
XTESTS_TEST_STRING_EQUAL(msgEl1 + msgEl2, results[0].statement);
XTESTS_TEST(pantheios::informational == results[0].severity);
}
static void test_1_8()
{
winstl_C_diagnostics_output_debug_line_2_m("", "");
XTESTS_TEST_INTEGER_EQUAL(1u, string.len);
XTESTS_TEST_MULTIBYTE_STRING_EQUAL("\n", string.ptr);
}
static void test_1_0()
{
recls_info_t entry;
recls_rc_t rc = Recls_Stat("", 0, &entry);
XTESTS_TEST_INTEGER_EQUAL(RECLS_RC_INVALID_NAME, rc);
}
static void test_1_3()
{
recls_info_t entry;
recls_rc_t rc = Recls_Stat("~", RECLS_F_MARK_DIRS, &entry);
if(RECLS_RC_OK == rc)
{
XTESTS_TEST_PASSED();
/* Verify that it's the home directory */
#if defined(PLATFORMSTL_OS_IS_WINDOWS) || \
( defined(PLATFORMSTL_OS_IS_UNIX) && \
defined(_WIN32))
XTESTS_TEST_RECLS_STRING_EQUAL_N_APPROX(s_home, entry->path.begin, strlen(s_home));
#elif defined(PLATFORMSTL_OS_IS_UNIX)
XTESTS_TEST_RECLS_STRING_EQUAL_N(s_home, entry->path.begin, strlen(s_home));
#else
# error platform not discriminated
#endif
Recls_CloseDetails(entry);
}
else
{
XTESTS_TEST_INTEGER_EQUAL(RECLS_RC_OK, rc);
}
}
static void test_1_05()
{
// 1. Setup
pantheios::be::test::reset();
// 2. Create test data
pantheios::boolean::set_value_strings(PSTR("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), PSTR("T"));
pantheios::log_NOTICE(PSTR("{"), pantheios::boolean(false), PSTR("}"));
pantheios::log_NOTICE(PSTR("{"), pantheios::boolean(true), PSTR("}"));
pantheios::boolean::set_value_strings(NULL, NULL);
pantheios::log_NOTICE(PSTR("{"), pantheios::boolean(false), PSTR("}"));
pantheios::log_NOTICE(PSTR("{"), pantheios::boolean(true), PSTR("}"));
// 3. Verification
pantheios::be::test::Results results = pantheios::be::test::results();
XTESTS_TEST(!results.empty());
XTESTS_TEST_INTEGER_EQUAL(4u, results.size());
XTESTS_TEST_STRING_EQUAL(PSTR("{ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff}"), results[0].statement);
XTESTS_TEST_STRING_EQUAL(PSTR("{T}"), results[1].statement);
XTESTS_TEST_STRING_EQUAL(PSTR("{false}"), results[2].statement);
XTESTS_TEST_STRING_EQUAL(PSTR("{true}"), results[3].statement);
}
static void test_1_01()
{
// 1. Setup
const PAN_CHAR_T prefix[] = PSTR("process: ");
PAN_CHAR_T pid_[21 + STLSOFT_NUM_ELEMENTS(prefix)];
PAN_CHAR_T const* pid = stlsoft::integer_to_string(&pid_[0], STLSOFT_NUM_ELEMENTS(pid_), pan_get_pid_());
PAN_CHAR_T const* stmt = pid - (STLSOFT_NUM_ELEMENTS(prefix) - 1);
#ifdef PANTHEIOS_USE_WIDE_STRINGS
::wcsncpy(const_cast<PAN_CHAR_T*>(stmt), prefix, (STLSOFT_NUM_ELEMENTS(prefix) - 1));
#else /* ? PANTHEIOS_USE_WIDE_STRINGS */
::strncpy(const_cast<PAN_CHAR_T*>(stmt), prefix, (STLSOFT_NUM_ELEMENTS(prefix) - 1));
#endif /* PANTHEIOS_USE_WIDE_STRINGS */
pantheios::be::test::reset();
// 2. Create test data
pantheios::log_NOTICE(pantheios::processId);
pantheios::log_NOTICE(prefix, pantheios::processId);
// 3. Verification
pantheios::be::test::Results results = pantheios::be::test::results();
XTESTS_TEST_BOOLEAN_FALSE(results.empty());
XTESTS_REQUIRE(XTESTS_TEST_INTEGER_EQUAL(2u, results.size()));
XTESTS_TEST_STRING_EQUAL(pid, results[0].statement);
XTESTS_TEST_STRING_EQUAL(stmt, results[1].statement);
}
static void test_1_10()
{
winstl_C_diagnostics_output_debug_line_2_m("abcdefghijklm", "nopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
XTESTS_TEST_INTEGER_EQUAL(53u, string.len);
XTESTS_TEST_MULTIBYTE_STRING_EQUAL("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n", string.ptr);
}
static void test_1_2()
{
winstl_C_diagnostics_output_debug_line_1_m("abc");
XTESTS_TEST_INTEGER_EQUAL(4u, string.len);
XTESTS_TEST_MULTIBYTE_STRING_EQUAL("abc\n", string.ptr);
}
static void test_1_1()
{
PAN_CHAR_T const pi[] = "test_1_1";
int r;
s_PI_N = pi;
r = pantheios_init();
XTESTS_TEST_INTEGER_EQUAL(2, s_numGPI);
if(r < 0)
{
XTESTS_FAIL("could not initialise libraries");
}
else
{
XTESTS_TEST_INTEGER_EQUAL(1, s_numInits);
XTESTS_TEST_INTEGER_EQUAL(0, s_numUninits);
XTESTS_TEST_INTEGER_EQUAL(2, s_numGPI);
XTESTS_TEST_MULTIBYTE_STRING_EQUAL("test_1_1", pantheios_getProcessIdentity());
XTESTS_TEST_POINTER_EQUAL(pi, pantheios_getProcessIdentity());
pantheios_uninit();
XTESTS_TEST_INTEGER_EQUAL(1, s_numInits);
XTESTS_TEST_INTEGER_EQUAL(1, s_numUninits);
XTESTS_TEST_INTEGER_EQUAL(4, s_numGPI);
}
}
static void test_1_10()
{
std::string sink;
ff::flush(ff::fmt(sink, FF_STR("{0}"), FF_STR("")));
XTESTS_TEST_INTEGER_EQUAL(0u, sink.size());
XTESTS_TEST_STRING_EQUAL("", sink.data());
ff::flush(ff::fmt(sink, FF_STR("{0}"), FF_STR("abc")));
XTESTS_TEST_INTEGER_EQUAL(3u, sink.size());
XTESTS_TEST_STRING_EQUAL("abc", sink.data());
ff::flush(ff::fmt(sink, FF_STR("{0}"), FF_STR("")));
XTESTS_TEST_INTEGER_EQUAL(3u, sink.size());
XTESTS_TEST_STRING_EQUAL("abc", sink.data());
}
static void test_1_13()
{
recls_char_t result[2];
size_t cch = Recls_SqueezePath(RECLS_LITERAL("abc/def/ghi"), &result[0], STLSOFT_NUM_ELEMENTS(result) - 1);
result[cch] = '\0';
XTESTS_TEST_INTEGER_EQUAL(1u, cch);
XTESTS_TEST_STRING_EQUAL(RECLS_LITERAL("g"), result);
}
static void test_1_0()
{
recls_char_t result[1];
size_t cch = Recls_SqueezePath(RECLS_LITERAL(""), NULL, 0);
result[cch] = '\0';
XTESTS_TEST_INTEGER_EQUAL(0u, cch);
XTESTS_TEST_STRING_EQUAL(RECLS_LITERAL(""), result);
}
static void test_2_00()
{
char const enc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ=";
unsigned char bytes[10];
B64_RC rc = B64_RC_OK;
size_t n = b64_decode2(enc, STLSOFT_NUM_ELEMENTS(enc) - 1u, &bytes[0], sizeof(bytes), 0, NULL, &rc);
XTESTS_TEST_INTEGER_EQUAL(0u, n);
XTESTS_TEST_ENUM_EQUAL(B64_RC_INSUFFICIENT_BUFFER, rc);
}
static void test_comstl_C_BSTR_create_w_1()
{
{
BSTR s = comstl_C_BSTR_create_w(NULL);
XTESTS_TEST_POINTER_EQUAL(NULL, s);
XTESTS_TEST_INTEGER_EQUAL(0u, SysStringLen(s));
XTESTS_TEST_INTEGER_EQUAL(SysStringLen(s), comstl_C_BSTR_len(s));
}
{
BSTR s = comstl_C_BSTR_create_w(L"");
XTESTS_TEST_POINTER_NOT_EQUAL(NULL, s);
XTESTS_TEST_INTEGER_EQUAL(0u, SysStringLen(s));
XTESTS_TEST_INTEGER_EQUAL(SysStringLen(s), comstl_C_BSTR_len(s));
comstl_C_BSTR_destroy(s);
}
}
static void test_comstl_C_BSTR_compare()
{
BSTR abc = SysAllocString(L"abc");
BSTR def = SysAllocString(L"def");
XTESTS_TEST_INTEGER_EQUAL(0, comstl_C_BSTR_compare(NULL, NULL));
XTESTS_TEST_INTEGER_EQUAL(0, comstl_C_BSTR_compare(abc, abc));
XTESTS_TEST_INTEGER_NOT_EQUAL(0, comstl_C_BSTR_compare(abc, def));
XTESTS_TEST_INTEGER_NOT_EQUAL(0, comstl_C_BSTR_compare(def, abc));
XTESTS_TEST_INTEGER_LESS(0, comstl_C_BSTR_compare(NULL, abc));
XTESTS_TEST_INTEGER_GREATER(0, comstl_C_BSTR_compare(abc, NULL));
XTESTS_TEST_INTEGER_LESS(0, comstl_C_BSTR_compare(NULL, def));
XTESTS_TEST_INTEGER_GREATER(0, comstl_C_BSTR_compare(def, NULL));
XTESTS_TEST_INTEGER_LESS(0, comstl_C_BSTR_compare(abc, def));
XTESTS_TEST_INTEGER_GREATER(0, comstl_C_BSTR_compare(def, abc));
comstl_C_BSTR_destroy(abc);
comstl_C_BSTR_destroy(def);
}
static void test_comstl_C_BSTR_create_a_2()
{
char const* const strings[] =
{
""
, "a"
, "abc"
, "abcdefghijklmnopqrstuvwxyz"
, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
};
{ size_t i; for(i = 0; i != dimensionof(strings); ++i)
{
BSTR const s = comstl_C_BSTR_create_a(strings[i]);
XTESTS_TEST_WIDE_STRING_EQUAL(m2w(strings[i]), s);
XTESTS_TEST_INTEGER_EQUAL(strlen(strings[i]), SysStringLen(s));
XTESTS_TEST_INTEGER_EQUAL(SysStringLen(s), comstl_C_BSTR_len(s));
comstl_C_BSTR_destroy(s);
}}
}
static void test_1_1()
{
{
recls_directoryResults_t results;
recls_rc_t rc = Recls_CreateDirectory(".", &results);
XTESTS_TEST_ENUM_EQUAL(RECLS_RC_OK, rc);
XTESTS_TEST_INTEGER_EQUAL(s_cwdLen, results.resultingLength);
}
{
recls_rc_t rc = Recls_CreateDirectory(".", NULL);
XTESTS_TEST_ENUM_EQUAL(RECLS_RC_OK, rc);
}
}
static void test_1_02()
{
const string_t hid = pan_get_hid_();
{ for(size_t i = 1; i != 1001; ++i)
{
pantheios::util::auto_buffer_selector<PAN_CHAR_T, 256>::type hostname(i);
const size_t len = pantheios::getHostName(hostname);
// The function had enough space, so it will return the length
// of the intended hostname ...
XTESTS_TEST_INTEGER_EQUAL(hid.size(), len);
// ... and will have written the hostname
XTESTS_TEST_STRING_EQUAL(hid, hostname.data());
}}
}
static void test_01()
{
// 1. Setup
pantheios::be::test::reset();
// 2. Create test data
// 3. Verification
pantheios::be::test::Results results = pantheios::be::test::results();
XTESTS_TEST_BOOLEAN_TRUE(results.empty());
XTESTS_TEST_INTEGER_EQUAL(0u, results.size());
}
static void test_1_2()
{
{
recls_directoryResults_t results;
recls_rc_t rc = Recls_CreateDirectory(RECLS_TEST_DIR_ROOT, &results);
XTESTS_TEST_ENUM_EQUAL(RECLS_RC_OK, rc);
XTESTS_TEST_INTEGER_EQUAL(RECLS_TEST_DIR_ROOT_LEN, results.resultingLength);
}
{
recls_rc_t rc = Recls_CreateDirectory(RECLS_TEST_DIR_ROOT, NULL);
XTESTS_TEST_ENUM_EQUAL(RECLS_RC_OK, rc);
}
Recls_RemoveDirectory(RECLS_TEST_DIR_ROOT, RECLS_REMDIR_F_REMOVE_FILES, NULL);
}
static void test_2_03()
{
// 1. Setup
pantheios::be::test::reset();
// 2. Create test data
pantheios::log_NOTICE("[", pantheios::w2m(std::wstring(L"abc")), "]");
// 3. Verification
pantheios::be::test::Results results = pantheios::be::test::results();
XTESTS_TEST(!results.empty());
XTESTS_TEST_INTEGER_EQUAL(1u, results.size());
XTESTS_TEST_MULTIBYTE_STRING_EQUAL("[abc]", results[0].statement);
}
static void test_3_09()
{
// 1. Setup
pantheios::be::test::reset();
// 2. Create test data
pantheios::log_NOTICE(pantheios::w2m(stlsoft::simple_wstring(L"")));
// 3. Verification
pantheios::be::test::Results results = pantheios::be::test::results();
XTESTS_TEST(!results.empty());
XTESTS_TEST_INTEGER_EQUAL(1u, results.size());
XTESTS_TEST_MULTIBYTE_STRING_EQUAL("", results[0].statement);
}
static void test_11()
{
// 1. Setup
pantheios::be::test::reset();
// 2. Create test data
const size_t numEntries = 1000;
{ for(size_t i = 0; i < numEntries; ++i)
{
if(0 == (i % 2))
{
pantheios::log(pantheios::informational, PSTR("a"), PSTR("b"), PSTR("c"), PSTR("d"), PSTR("e"), PSTR("f"), PSTR("g"), PSTR("h"), PSTR("i"), PSTR("j"), PSTR("k"), PSTR("l"), PSTR("m"), PSTR("n"), PSTR("o"), PSTR("p"), PSTR("q"), PSTR("r"), PSTR("s"), PSTR("t"), PSTR("u"), PSTR("v"), PSTR("w"), PSTR("x"), PSTR("y"), PSTR("z"));
}
else
{
pantheios::log(pantheios::informational, PSTR("A"), PSTR("B"), PSTR("C"), PSTR("D"), PSTR("E"), PSTR("F"), PSTR("G"), PSTR("H"), PSTR("I"), PSTR("J"), PSTR("K"), PSTR("L"), PSTR("M"), PSTR("N"), PSTR("O"), PSTR("P"), PSTR("Q"), PSTR("R"), PSTR("S"), PSTR("T"), PSTR("U"), PSTR("V"), PSTR("W"), PSTR("X"), PSTR("Y"), PSTR("Z"));
}
}}
// 3. Verification
pantheios::be::test::Results results = pantheios::be::test::results();
XTESTS_TEST_INTEGER_EQUAL(numEntries, results.size());
{ for(size_t i = 0; i < numEntries; ++i)
{
if(0 == (i % 2))
{
XTESTS_TEST_STRING_EQUAL(PSTR("abcdefghijklmnopqrstuvwxyz"), results[i].statement);
}
else
{
XTESTS_TEST_STRING_EQUAL(PSTR("ABCDEFGHIJKLMNOPQRSTUVWXYZ"), results[i].statement);
}
}}
}
