erabo/spiegel-keyman
1
0
Fork 0
mirror of https://github.com/keymanapp/keyman.git synced 2026-08-05 16:35:33 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 11
spiegel-keyman/core/tests/unit/kmnkbd/kmx_xstring.tests.cpp

1436 lines
64 KiB
C++
Raw Blame History

/*
* Keyman is copyright (C) SIL International. MIT License.
*
* Keyman Core - KMX Extended String unit tests
*/
#ifndef KM_CORE_LIBRARY
#define KM_CORE_LIBRARY
#endif
#ifndef USE_CHAR16_T
#define USE_CHAR16_T
#endif
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <string>
#include "../../../src/kmx/kmx_xstring.h"
#include <kmx_file.h>
#include <test_assert.h>
using namespace km::core::kmx;
using namespace std;
#define U_1F609_WINKING_FACE u"\U0001F609"
PKMX_WCHAR find_ptr_to_last_character(PKMX_WCHAR p_first) {
auto length = std::u16string(p_first).length();
if (length > 0)
return p_first + length - 1;
else
return p_first;
}
void test_decxstr() {
PKMX_WCHAR p_start; // pointer start of input
PKMX_WCHAR p; // pointer end of input
PKMX_WCHAR q; // pointer output
// -------------------------------------------------------------------------------------------------------------------------------------------------------
// UC_SENTINEL followed by valid CODE_xx with sufficient & insufficient number of parameters
// -------------------------------------------------------------------------------------------------------------------------------------------------------
p_start = (PKMX_WCHAR) C_CODE_ANY(u"\u0002");
p = p_start + 2; // \u0002 in the middle of the otherwise valid UC_SENTINEL CODE_ANY sequence
q = decxstr(p, p_start);
test_assert(q == p - 1);
p_start = (PKMX_WCHAR)u"abc" C_CODE_ANY(u"\u0001");
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p-1));
p_start = (PKMX_WCHAR) C_CODE_ANY(u"\u0001");
p = p_start + 3; // nul, i.e. at the end of the valid UC_SENTINEL CODE_ANY sequence
q = decxstr(p, p_start);
test_assert(q == p - 3);
p_start = (PKMX_WCHAR)u"abc" C_CODE_ANY(u"\u0001") u"\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p-3));
p_start = (PKMX_WCHAR)u"abc" C_CODE_ANY(u"\u0001") U_1F609_WINKING_FACE;
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p-1));
p_start = (PKMX_WCHAR)u"abc" C_CODE_ANY(u"\u0001") U_1F609_WINKING_FACE;
p = find_ptr_to_last_character(p_start)-1;
q = decxstr(p, p_start);
test_assert(q == (p-3));
// -------------------------------------------------------------------------------------------------------------------------------------------------------
// even more tests: check for use UC_SENTINEL with F000
// -------------------------------------------------------------------------------------------------------------------------------------------------------
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL u"\uF000";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p-1));
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL u"\uF000d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL u"\uF000\u0001";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL u"\uF000\u0002";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL u"\uF000\u0001\u0001";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL u"\uF000\u0002\u0001";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL u"\uF000\u0001\u0001d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL u"\uF000\u0002\u0001\u0001";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL u"\uF000\u0002\u0001\u0001d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
// -------------------------------------------------------------------------------------------------------------------------------------------------------
// more tests: check if we might end up left of pstart
// -------------------------------------------------------------------------------------------------------------------------------------------------------
p_start = (PKMX_WCHAR)u"\u0001";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (NULL ));
p_start = (PKMX_WCHAR)u"\u0001\u0001";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"\u0001\u0001\u0001";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR) U_UC_SENTINEL U_CODE_ANY;
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
// Note: this test puts the pointer into the middle of a valid `UC_SENTINEL CODE_ANY <store>`
// so we should expect it to not be properly understood.
p_start = (PKMX_WCHAR) C_CODE_ANY(u"\u0001");
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR) C_CODE_ANY(u"\u0001") u"\u0001";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 3));
p_start = (PKMX_WCHAR)u"\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (NULL));
p_start = (PKMX_WCHAR)u"\u0014\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"\u0014\u0014\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"\u0014\u0014\u0014\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"\u0014\u0014\u0014\u0014\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR)u"\u0014\u0014\u0014\u0014\u0014\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR) U_UC_SENTINEL u"\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
// 0x14 = CODE_IFOPT which has 3 parameters, so this is an invalid, so
// go back only one char
p_start = (PKMX_WCHAR) U_UC_SENTINEL u"\u0014\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR) U_UC_SENTINEL u"\u0014\u0014\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR) C_CODE_IFOPT(u"\u0014", u"\u0014", u"\u0014");
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
p_start = (PKMX_WCHAR) C_CODE_IFOPT(u"\u0014", u"\u0014", u"\u0014") u"\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 5));
p_start = (PKMX_WCHAR) C_CODE_IFOPT(u"\u0014", u"\u0014", u"\u0014") u"\u0014\u0014";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1));
// -------------------------------------------------------------------------------------------------------------------------------------------------------
// -- differences in pointer movement for new decxstr ----------------------------------------------------------------------------------------------------
// ----- OLD version of decxstr: 0x0A not used => return ( p - 1) , 0x0C not used => return ( p - 1) , 0x0E = 1 => return ( p - 3)
// ----- NEW version of decxstr: Values set in in CODE__SIZE[]: 0x0A = 2 => return ( p - 4) , 0x0C =1 => return ( p - 3) , 0x0E = 0 => return ( p - 1)
// -------------------------------------------------------------------------------------------------------------------------------------------------------
// runs OK with NEW version of decxstr (with CODE_EXTENDED pointer moves 3 ( 4 altogether)
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL U_CODE_EXTENDED u"\u0001" u"\u0001" u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 4) );
//runs OK with NEW version of decxstr (with CODE_SWITCH pointer moves 2 ( 3 altogether)
p_start = (PKMX_WCHAR)u"abc" C_CODE_SWITCH(u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 3) );
// runs OK with NEW version of decxstr (with CODE_CLEARCONTEXT pointer moves 0 ( 1 altogether)
p_start = (PKMX_WCHAR)u"abc" C_CODE_CLEARCONTEXT() u"\u0001d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
// runs OK with OLD version and NEW version of decxstr
p_start = (PKMX_WCHAR)u"abc" C_CODE_CLEARCONTEXT() u"\u0001";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 2) );
// ---------------------------------------------------------------------------------------
// ---- character
// ---------------------------------------------------------------------------------------
p_start = (PKMX_WCHAR)u"abcd";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
// ---------------------------------------------------------------------------------------
// ---- p <= pstart
// ---------------------------------------------------------------------------------------
p_start = (PKMX_WCHAR)u"abc";
p = find_ptr_to_last_character(p_start)-5;
q = decxstr(p, p_start);
test_assert(q == (NULL) );
p_start = (PKMX_WCHAR)u"a";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (NULL) );
// ---------------------------------------------------------------------------------------
// ---- p= UC_SENTINEL_EXTENDED
// ---------------------------------------------------------------------------------------
p_start = (PKMX_WCHAR)u"abc" C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" U_CODE_EXTENDEDEND);
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" u"\u0007" u"\u0008" U_CODE_EXTENDEDEND);
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" U_CODE_EXTENDEDEND) u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 8) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" u"\u0007" u"\u0008" U_CODE_EXTENDEDEND) u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 11) );
// ---------------------------------------------------------------------------------------
// ---- Surrogate Pair
// ---------------------------------------------------------------------------------------
p_start = (PKMX_WCHAR)u"abc" U_1F609_WINKING_FACE;
p = find_ptr_to_last_character(p_start)-1;
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR)u"abc" U_1F609_WINKING_FACE;
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR)u"abc" U_1F609_WINKING_FACE u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 2) );
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL U_1F609_WINKING_FACE;
p = find_ptr_to_last_character(p_start)-1;
q = decxstr(p, p_start);
test_assert(q == (p-1));
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL U_1F609_WINKING_FACE;
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p-1));
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL U_1F609_WINKING_FACE u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p-2));
// ---------------------------------------------------------------------------------------
// ---- CODE_
// ---------------------------------------------------------------------------------------
for (auto code = 1 /* CODE_ANY */; code <= CODE_LASTCODE; code++) {
if (code == UC_SENTINEL_EXTENDEDEND) {
// We won't try and test that here as it won't assert in the
// same way
continue;
}
auto size = CODE__SIZE[code];
std::u16string str(u"abc" U_UC_SENTINEL);
str.append(1, code);
str.append(size < 0 ? 0 : size, u'\u0001');
p_start = (PKMX_WCHAR) str.c_str();
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1)); // this is in the middle of the sequence so it should always go back a single unit
str.append(u"a");
p_start = (PKMX_WCHAR)str.c_str();
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
if (size < 0) {
test_assert(q == (p - 1)); // this is in the middle of the sequence so it should always go back a single unit
} else {
test_assert(q == (p - size - 2)); /* UC_SENTINEL + code + (CODE__SIZE = number of params) */
}
}
// ---------------------------------------------------------------------------------------
// ---- CODE_ followed by letter
// ---------------------------------------------------------------------------------------
p_start = (PKMX_WCHAR)u"abc" C_CODE_ANY(u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 3) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_INDEX(u"\u0001", u"\u0001d");
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 4) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_CONTEXT() u"\u0001d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_NUL() u"\u0001d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_USE(u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 3) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_RETURN() u"\u0001d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_BEEP() u"\u0001d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_DEADKEY(u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 3) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_CALL(u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 3) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_CONTEXTEX(u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 3) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_NOTANY(u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 3) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_SETOPT(u"\u0001", u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 4) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_IFOPT(u"\u0001", u"\u0001", u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 5) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_SAVEOPT(u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 3) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_RESETOPT(u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 3) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_IFSYSTEMSTORE(u"\u0001", u"\u0001", u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 5) );
p_start = (PKMX_WCHAR)u"abc" C_CODE_SETSYSTEMSTORE(u"\u0001", u"\u0001") u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 4) );
// ---------------------------------------------------------------------------------------
// ---- other
// ---------------------------------------------------------------------------------------
p_start = (PKMX_WCHAR)u"abc" C_CODE_INDEX(u"d", u"e") u"f\u0001";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR)u"abc" U_UC_SENTINEL;
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
// pointer in the middle of a surrogate pair, so beware!
p_start = (PKMX_WCHAR) U_UC_SENTINEL U_1F609_WINKING_FACE;
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR)u"\u0014d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR) U_UC_SENTINEL;
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == NULL );
p_start = (PKMX_WCHAR) U_UC_SENTINEL u"d";
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == (p - 1) );
p_start = (PKMX_WCHAR) U_UC_SENTINEL U_UC_SENTINEL;
p = find_ptr_to_last_character(p_start);
q = decxstr(p, p_start);
test_assert(q == p - 1 );
}
void test_incxstr() {
PKMX_WCHAR p; // pointer input to incxstr()
PKMX_WCHAR q; // pointer output to incxstr()
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- NULL, SURROGATE PAIRS, NON_UC_SENTINEL, ONE CHARACTER ---------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for empty string ------------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) u"\0";
q = incxstr(p);
test_assert(q == p);
// --- Test for character ---------------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) u"\u1234";
q = incxstr(p);
test_assert(q == p+1);
// --- Test for surrogate pair ----------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p+2);
// --- Test for one <control> -----------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR)u"\u0012";
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for FFFF only -------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_UC_SENTINEL;
q = incxstr(p);
test_assert(q == p + 1);
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- UC_SENTINEL WITHOUT \0 ----------------------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for FFFF +CODE_INDEX --------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_INDEX(u"\u0002", u"\u0001");
q = incxstr(p);
test_assert(q == p + 4);
// --- Test for FFFF +CODE_USE ----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_USE(u"\u0001");
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_DEADKEY ------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_DEADKEY(u"\u0001");
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF CODE_EXTENDED --------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" U_CODE_EXTENDEDEND);
q = incxstr(p);
test_assert(q == p + 9);
// --- Test for FFFF +CODE_CLEARCONTEXT ------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CLEARCONTEXT() u"\u0001";
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for FFFF +CODE_CALL ----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CALL(u"\u0001");
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_CONTEXTEX ---------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CONTEXTEX(u"\u0001");
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_IFOPT -------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_IFOPT(u"\u0002", u"\u0002", u"\u0001");
q = incxstr(p);
test_assert(q == p + 5);
// --- Test for FFFF +CODE_IFSYSTEMSTORE ------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_IFSYSTEMSTORE(u"\u0002", u"\u0002", u"\u0001");
q = incxstr(p);
test_assert(q == p + 5);
// --- Test for FFFF +CODE_SETOPT ----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SETOPT(u"\u0002", u"\u0001");
q = incxstr(p);
test_assert(q == p + 4);
// --- Test for FFFF +CODE_SETSYSTEMRESTORE ---------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SETSYSTEMSTORE(u"\u0002", u"\u0001");
q = incxstr(p);
test_assert(q == p + 4);
// --- Test for FFFF +CODE_RESETOPT -----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_RESETOPT(u"\u0001");
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_SAVEOPT -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SAVEOPT(u"\u0001");
q = incxstr(p);
test_assert(q == p + 3 );
// --- Test for FFFF +default ----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NUL();
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for FFFF + CODE_ANY -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_ANY(u"\u0001");
q = incxstr(p);
test_assert(q == p + 3 );
// --- Test for FFFF + CODE_CONTEXT -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CONTEXT() u"\u0001";
q = incxstr(p);
test_assert(q == p + 2 );
// --- Test for FFFF + CODE_RETURN -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_RETURN() u"\u0001";
q = incxstr(p);
test_assert(q == p + 2 );
// --- Test for FFFF + CODE_BEEP -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_BEEP() u"\u0001";
q = incxstr(p);
test_assert(q == p + 2 );
// --- Test for FFFF + CODE_SWITCH -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SWITCH(u"\u0001");
q = incxstr(p);
test_assert(q == p + 3 );
// --- Test for FFFF + NOTANY -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NOTANY(u"\u0001");
q = incxstr(p);
test_assert(q == p + 3 );
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- UC_SENTINEL WITH \0 AT DIFFERENT POSITIONS --------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for FFFF + control (earlier p+1) with \0 after first position --------------- unit test failed with old version of incxstr() -----
p = (PKMX_WCHAR) U_UC_SENTINEL u"\0\u0008\u0001";
q = incxstr(p);
test_assert(q == p+1);
// --- Test for FFFF +control (earlier p+1) with \0 after second position --------- unit test failed with old version of incxstr() -----
p = (PKMX_WCHAR) C_CODE_DEADKEY(u"\0") u"\u0001";
q = incxstr(p);
test_assert(q == p+2);
// --- Test for FFFF +control (earlier p+1) with \0 after third position ----- unit test failed with old version of incxstr() -----
p = (PKMX_WCHAR) C_CODE_DEADKEY(u"\u0001") u"\0";
q = incxstr(p);
test_assert(q == p+3)
// --- Test for FFFF +control (earlier p+2) with \0 after fourth position ----- unit test failed with old version of incxstr() ----
p = (PKMX_WCHAR) C_CODE_INDEX(u"\u0001", u"\u0001") u"\0";
q = incxstr(p);
test_assert(q == p+4);
// --- Test for FFFF +control (earlier p+3) with \0 after fifth position ----- unit test failed with old version of incxstr() ---------
p = (PKMX_WCHAR) C_CODE_IFOPT(u"\u0001", u"\u0001", u"\u0001") u"\0";
q = incxstr(p);
test_assert(q == p+5);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 6. position ----- unit test failed with old version of incxstr() -----
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\0" u"\u0005" u"\u0006" u"\u0007" U_CODE_EXTENDEDEND);
q = incxstr(p);
test_assert(q == p + 6);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 7. position ----- unit test failed with old version of incxstr()
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\0" u"\u0006" u"\u0007" U_CODE_EXTENDEDEND);
q = incxstr(p);
test_assert(q == p + 7);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 8. position ----- unit test failed with old version of incxstr() ----------
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" u"\0" u"\u0007" U_CODE_EXTENDEDEND);
q = incxstr(p);
test_assert(q == p + 8);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 9. position ----- unit test failed with old version of incxstr() ---
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" u"\u0007" u"\0" U_CODE_EXTENDEDEND);
q = incxstr(p);
test_assert(q == p + 9);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 10. position ----- unit test failed with old version of incxstr() -----------
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" u"\u0007" U_CODE_EXTENDEDEND) u"\0";
q = incxstr(p);
test_assert(q == p + 10);
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- UC_SENTINEL, INCOMPLETE & UNUSUAL SEQUENCES--------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for FFFF + \0 --------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_UC_SENTINEL u"\0";
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for FFFF +one character ------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_UC_SENTINEL u"\u0062";
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for FFFF +one <control> -----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NUL();
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for FFFF + one <control> + character -------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NUL() u"\u0062";
q = incxstr(p);
test_assert(q == p + 2);
//-------------------------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------------------------
//
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- NULL, SURROGATE PAIRS, NON_UC_SENTINEL, ONE CHARACTER WITH \u1234\u2468 At END
// ---------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for empty string
//---------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) u"\0\u1234\u2468";
q = incxstr(p);
test_assert(q == p);
// --- Test for character
// ---------------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR)u"\u1234\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 1);;
// --- Test for surrogate pair
// ----------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_1F609_WINKING_FACE u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for one <control>
// -----------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR)u"\u0012\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for FFFF only
// -------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_UC_SENTINEL u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 1);
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- UC_SENTINEL WITHOUT \0
// ----------------------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for FFFF +CODE_INDEX
// --------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_INDEX(u"\u0002", u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 4);
// --- Test for FFFF +CODE_USE
// ----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_USE(u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_DEADKEY
// ------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_DEADKEY(u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF CODE_EXTENDED
// --------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" U_CODE_EXTENDEDEND) u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 9);
// --- Test for FFFF +CODE_CLEARCONTEXT
// ------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CLEARCONTEXT() u"\u0001\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for FFFF +CODE_CALL
// ----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CALL(u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_CONTEXTEX
// ---------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CONTEXTEX(u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_IFOPT
// -------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_IFOPT(u"\u0002", u"\u0002", u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 5);
// --- Test for FFFF +CODE_IFSYSTEMSTORE
// ------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_IFSYSTEMSTORE(u"\u0002", u"\u0002", u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 5);
// --- Test for FFFF +CODE_SETOPT
// ----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SETOPT(u"\u0002", u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 4);
// --- Test for FFFF +CODE_SETSYSTEMRESTORE
// ---------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SETSYSTEMSTORE(u"\u0002", u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 4);
// --- Test for FFFF +CODE_RESETOPT
// -----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_RESETOPT(u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_SAVEOPT
// -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SAVEOPT(u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +default
// ----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NUL() u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for FFFF + CODE_ANY -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_ANY(u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 3 );
// --- Test for FFFF + CODE_CONTEXT -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CONTEXT() u"\u0001\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 2 );
// --- Test for FFFF + CODE_RETURN -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_RETURN() u"\u0001\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 2 );
// --- Test for FFFF + CODE_BEEP -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_BEEP() u"\u0001\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 2 );
// --- Test for FFFF + CODE_SWITCH -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SWITCH(u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 3 );
// --- Test for FFFF + NOTANY -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NOTANY(u"\u0001") u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 3 );
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- UC_SENTINEL WITH \0 AT DIFFERENT POSITIONS
// --------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for FFFF + control (earlier p+1) with \0 after first position --------------- unit test failed with old version of
// incxstr() -----
p = (PKMX_WCHAR) U_UC_SENTINEL u"\0\u0008\u0001\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for FFFF +control (earlier p+1) with \0 after second position --------- unit test failed with old version of
// incxstr() -----
p = (PKMX_WCHAR) C_CODE_DEADKEY(u"\0") u"\u0001\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for FFFF +control (earlier p+1) with \0 after third position ----- unit test failed with old version of incxstr()
// -----
p = (PKMX_WCHAR) C_CODE_DEADKEY(u"\u0001") u"\0\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 3)
// --- Test for FFFF +control (earlier p+2) with \0 after fourth position ----- unit test failed with old version of
// incxstr() ----
p = (PKMX_WCHAR) C_CODE_INDEX(u"\u0001", u"\u0001") u"\0\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 4);
// --- Test for FFFF +control (earlier p+3) with \0 after fifth position ----- unit test failed with old version of incxstr()
// ---------
p = (PKMX_WCHAR) C_CODE_IFOPT(u"\u0001", u"\u0001", u"\u0001") u"\0\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 5);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 6. position ----- unit test failed with old
// version of incxstr() -----
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\0" u"\u0005" u"\u0006" u"\u0007" U_CODE_EXTENDEDEND) u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 6);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 7. position ----- unit test failed with old
// version of incxstr()
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\0" u"\u0006" u"\u0007" U_CODE_EXTENDEDEND) u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 7);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 8. position ----- unit test failed with old
// version of incxstr() ----------
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" u"\0" u"\u0007" U_CODE_EXTENDEDEND) u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 8);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 9. position ----- unit test failed with old
// version of incxstr() ---
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" u"\u0007" u"\0" U_CODE_EXTENDEDEND) u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 9);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 10. position ----- unit test failed with old
// version of incxstr() -----------
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" u"\u0007" U_CODE_EXTENDEDEND) u"\0\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 10);
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- UC_SENTINEL, INCOMPLETE & UNUSUAL SEQUENCES--------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for FFFF + \0
// --------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_UC_SENTINEL u"\0\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for FFFF +one character
// ------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_UC_SENTINEL u"\u0062\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for FFFF +one <control>
// -----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NUL() u"\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for FFFF + one <control> + character
// -------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NUL() u"\u0062\u1234\u2468";
q = incxstr(p);
test_assert(q == p + 2);
//-------------------------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- NULL, SURROGATE PAIRS, NON_UC_SENTINEL, ONE CHARACTER WITH SURROGATE PAIR \U0001F609 At END
// ---------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for empty string
//------------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR)u"\0" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p);
// --- Test for character
// ---------------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR)u"\u1234" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for surrogate pair
// ----------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_1F609_WINKING_FACE U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for one <control>
// -----------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR)u"\u0012" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for FFFF only
// -------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_UC_SENTINEL U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 1);
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- UC_SENTINEL WITHOUT \0
// ----------------------------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for FFFF +CODE_INDEX
// --------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_INDEX(u"\u0002", u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 4);
// --- Test for FFFF +CODE_USE
// ----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_USE(u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_DEADKEY
// ------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_DEADKEY(u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF CODE_EXTENDED
// --------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" U_CODE_EXTENDEDEND) U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 9);
// --- Test for FFFF +CODE_CLEARCONTEXT
// ------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CLEARCONTEXT() u"\u0001" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for FFFF +CODE_CALL
// ----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CALL(u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_CONTEXTEX
// ---------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CONTEXTEX(u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_IFOPT
// -------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_IFOPT(u"\u0002", u"\u0002", u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 5);
// --- Test for FFFF +CODE_IFSYSTEMSTORE
// ------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_IFSYSTEMSTORE(u"\u0002", u"\u0002", u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 5);
// --- Test for FFFF +CODE_SETOPT
// ----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SETOPT(u"\u0002", u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 4);
// --- Test for FFFF +CODE_SETSYSTEMRESTORE
// ---------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SETSYSTEMSTORE(u"\u0002", u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 4);
// --- Test for FFFF +CODE_RESETOPT
// -----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_RESETOPT(u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +CODE_SAVEOPT
// -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SAVEOPT(u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 3);
// --- Test for FFFF +default
// ----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NUL() U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for FFFF + CODE_ANY -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_ANY(u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 3 );
// --- Test for FFFF + CODE_CONTEXT -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_CONTEXT() u"\u0001" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 2 );
// --- Test for FFFF + CODE_RETURN -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_RETURN() u"\u0001" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 2 );
// --- Test for FFFF + CODE_BEEP -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_BEEP() u"\u0001" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 2 );
// --- Test for FFFF + CODE_SWITCH -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_SWITCH(u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 3 );
// --- Test for FFFF + NOTANY -----------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NOTANY(u"\u0001") U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 3 );
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- UC_SENTINEL WITH \0 AT DIFFERENT POSITIONS
// --------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for FFFF + control (earlier p+1) with \0 after first position --------------- unit test failed
// with old version of incxstr() -----
p = (PKMX_WCHAR) U_UC_SENTINEL u"\0\u0008\u0001" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for FFFF +control (earlier p+1) with \0 after second position --------- unit test failed with
// old version of incxstr() -----
p = (PKMX_WCHAR) C_CODE_DEADKEY(u"\0") u"\u0001" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for FFFF +control (earlier p+1) with \0 after third position ----- unit test failed with old
// version of incxstr() -----
p = (PKMX_WCHAR) C_CODE_DEADKEY(u"\u0001") u"\0" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 3)
// --- Test for FFFF +control (earlier p+2) with \0 after fourth position ----- unit test failed with
// old version of incxstr() ----
p = (PKMX_WCHAR) C_CODE_INDEX(u"\u0001", u"\u0001") u"\0" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 4);
// --- Test for FFFF +control (earlier p+3) with \0 after fifth position ----- unit test failed with old
// version of incxstr() ---------
p = (PKMX_WCHAR) C_CODE_IFOPT(u"\u0001", u"\u0001", u"\u0001") u"\0" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 5);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 6. position ----- unit test
// failed with old version of incxstr() -----
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\0" u"\u0005" u"\u0006" u"\u0007" U_CODE_EXTENDEDEND) U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 6);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 7. position ----- unit test
// failed with old version of incxstr()
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\0" u"\u0006" u"\u0007" U_CODE_EXTENDEDEND) U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 7);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 8. position ----- unit test
// failed with old version of incxstr() ----------
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" u"\0" u"\u0007" U_CODE_EXTENDEDEND) U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 8);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 9. position ----- unit test
// failed with old version of incxstr() ---
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" u"\u0007" u"\0" U_CODE_EXTENDEDEND) U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 9);
// --- Test for FFFF +control CODE_EXTENDED ----- (earlier p+n) with \0 after 10. position ----- unit test
// failed with old version of incxstr() -----------
p = (PKMX_WCHAR) C_CODE_EXTENDED(u"\u0001" u"\u0002" u"\u0003" u"\u0004" u"\u0005" u"\u0006" u"\u0007" U_CODE_EXTENDEDEND) u"\0" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 10);
// --------------------------------------------------------------------------------------------------------------------------------------------------
// ---- UC_SENTINEL, INCOMPLETE & UNUSUAL SEQUENCES--------------------------------------------------------------------------------------------------
// --------------------------------------------------------------------------------------------------------------------------------------------------
// --- Test for FFFF + \0
// --------------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_UC_SENTINEL u"\0" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for FFFF +one character
// ------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) U_UC_SENTINEL u"\u0062" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 1);
// --- Test for FFFF +one <control>
// -----------------------------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NUL() U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 2);
// --- Test for FFFF + one <control> + character
// -------------------------------------------------------------------------------------------
p = (PKMX_WCHAR) C_CODE_NUL() u"\u0062" U_1F609_WINKING_FACE;
q = incxstr(p);
test_assert(q == p + 2);
}
void test_xstrlen() {
test_assert_equal(xstrlen((PKMX_WCHAR)u""), 0);
test_assert_equal(xstrlen((PKMX_WCHAR)u"1"), 1);
test_assert_equal(xstrlen((PKMX_WCHAR)u"1234567890"), 10);
test_assert_equal(xstrlen((PKMX_WCHAR) C_CODE_DEADKEY(u"\u0001") u"a"), 2);
test_assert_equal(xstrlen((PKMX_WCHAR) C_CODE_IFOPT(u"\u0001", u"\u0002", u"\u0003") u"a"), 2);
test_assert_equal(xstrlen((PKMX_WCHAR) C_CODE_IFSYSTEMSTORE(u"\u0001", u"\u0002", u"\u0003") u"a"), 2);
test_assert_equal(xstrlen((PKMX_WCHAR) U_1F609_WINKING_FACE u"a"), 2);
}
void
test_xstrlen_ignoreifopt() {
test_assert_equal(xstrlen_ignoreifopt((PKMX_WCHAR)u""), 0);
test_assert_equal(xstrlen_ignoreifopt((PKMX_WCHAR)u"1"), 1);
test_assert_equal(xstrlen_ignoreifopt((PKMX_WCHAR)u"1234567890"), 10);
test_assert_equal(xstrlen_ignoreifopt((PKMX_WCHAR) C_CODE_DEADKEY(u"\u0001") u"a"), 2);
test_assert_equal(xstrlen_ignoreifopt((PKMX_WCHAR) C_CODE_IFOPT(u"\u0001", u"\u0002", u"\u0003") u"a"), 1);
test_assert_equal(xstrlen_ignoreifopt((PKMX_WCHAR) C_CODE_IFSYSTEMSTORE(u"\u0001", u"\u0002", u"\u0003") u"a"), 1);
test_assert_equal(xstrlen_ignoreifopt((PKMX_WCHAR) U_1F609_WINKING_FACE u"a"), 2);
}
void
test_utf32() {
std::cout << "== " << __FUNCTION__ << std::endl;
const KMX_DWORD u295 = 0x0127; // ħ
test_assert(Uni_IsBMP(u295));
const char16_t hmaqtugha = Uni_UTF32BMPToUTF16(u295);
test_assert(hmaqtugha == 0x0127);
char16_single c0;
int l0 = Utf32CharToUtf16(u295, c0);
test_assert(l0 == 1);
test_assert(c0.ch[0] == 0x0127);
test_assert(c0.ch[1] == 0);
std::u16string s0 = std::u16string(c0.ch, l0);
test_assert(s0 == std::u16string(u"ħ"));
test_assert_equal(s0.at(0), 0x0127);
const KMX_DWORD scat = 0x0001F640; // 🙀
test_assert(!Uni_IsBMP(scat));
char16_single c1;
int l1 = Utf32CharToUtf16(scat, c1);
test_assert(l1 == 2);
test_assert_equal(c1.ch[0], 0xD83D);
test_assert_equal(c1.ch[1], 0xDE40);
test_assert_equal(c1.ch[2], 0);
std::u16string s1 = std::u16string(c1.ch, l1);
test_assert_equal(s1.at(0), 0xD83D);
test_assert_equal(s1.at(1), 0xDE40);
test_assert(s1 == std::u16string(u"🙀"));
}
void
test_u16string_to_u32string() {
std::cout << "== " << __FUNCTION__ << std::endl;
// normal cases
{
const std::u32string str = u16string_to_u32string(u"");
test_assert_equal(str.length(), 0);
}
{
const std::u32string str = u16string_to_u32string(u"e");
test_assert_equal(str.length(), 1);
test_assert_equal(str.at(0), 0x0065);
}
{
const std::u32string str = u16string_to_u32string(u"🙀");
test_assert_equal(str.length(), 1);
test_assert_equal(str.at(0), 0x0001F640);
}
{
const std::u32string str = u16string_to_u32string(u"Ω🙀");
test_assert_equal(str.length(), 2);
test_assert_equal(str.at(0), u'Ω');
test_assert_equal(str.at(1), 0x0001F640);
}
// error cases
{
std::u16string half_cat;
half_cat.push_back(0xD83D); // mismatched lead surrogate
const std::u32string str = u16string_to_u32string(half_cat);
test_assert_equal(str.length(), 1);
test_assert_equal(str.at(0), 0xFFFD);
}
{
std::u16string half_cat;
half_cat.push_back(0xD83D); // mismatched lead surrogate
half_cat.push_back(u'Ω'); // with following text
const std::u32string str = u16string_to_u32string(half_cat);
test_assert_equal(str.length(), 2);
test_assert_equal(str.at(0), 0xFFFD);
test_assert_equal(str.at(1), u'Ω');
}
{
std::u16string half_cat;
half_cat.push_back(0xDE40); // mismatched trail surrogate
const std::u32string str = u16string_to_u32string(half_cat);
test_assert_equal(str.length(), 1);
test_assert_equal(str.at(0), 0xFFFD);
}
{
std::u16string no_cat;
no_cat.push_back(0xDE40);
no_cat.push_back(0xD83D);
const std::u32string str = u16string_to_u32string(no_cat);
test_assert_equal(str.length(), 2);
test_assert_equal(str.at(0), 0xFFFD);
test_assert_equal(str.at(1), 0xFFFD);
}
}
void
test_u32string_to_u16string() {
std::cout << "== " << __FUNCTION__ << std::endl;
// normal cases
{
const auto str = u32string_to_u16string(U"");
test_assert_equal(str.length(), 0);
}
{
const auto str = u32string_to_u16string(U"e");
test_assert_equal(str.length(), 1);
test_assert_equal(str.at(0), 0x0065);
}
{
const auto str = u32string_to_u16string(U"🙀");
test_assert_equal(str.length(), 2);
test_assert_equal(str.at(0), 0xD83D);
test_assert_equal(str.at(1), 0xDE40);
}
{
const auto str = u32string_to_u16string(U"Ω🙀");
test_assert_equal(str.length(), 3);
test_assert_equal(str.at(0), u'Ω');
test_assert_equal(str.at(1), 0xD83D);
test_assert_equal(str.at(2), 0xDE40);
}
}
void test_is_valid() {
std::cout << "== " << __FUNCTION__ << std::endl;
// valid
test_assert_equal(Uni_IsValid(0x0000), true);
test_assert_equal(Uni_IsValid(0x0127), true);
test_assert_equal(Uni_IsValid(U'🙀'), true);
// invalid
test_assert_equal(Uni_IsValid(0xDECAFBAD), false); // out of range
test_assert_equal(Uni_IsValid(0x566D4128), false);
test_assert_equal(Uni_IsValid(0xFFFF), false); // nonchar
test_assert_equal(Uni_IsValid(0xFFFE), false); // nonchar
test_assert_equal(Uni_IsValid(0x10FFFF), false); // nonchar
test_assert_equal(Uni_IsValid(0x10FFFE), false); // nonchar
test_assert_equal(Uni_IsValid(0x01FFFF), false); // nonchar
test_assert_equal(Uni_IsValid(0x01FFFE), false); // nonchar
test_assert_equal(Uni_IsValid(0x02FFFF), false); // nonchar
test_assert_equal(Uni_IsValid(0x02FFFE), false); // nonchar
test_assert_equal(Uni_IsValid(0xFDD1), false); // nonchar
test_assert_equal(Uni_IsValid(0xFDD0), false); // nonchar
// positive range test
test_assert_equal(Uni_IsValid(0x100000, 0x10FFFD), true);
test_assert_equal(Uni_IsValid(0x10, 0x20), true);
test_assert_equal(Uni_IsValid(0x100000, 0x10FFFD), true);
// all valid ranges in BMP
test_assert_equal(Uni_IsValid(0x0000, 0xD7FF), true);
test_assert_equal(Uni_IsValid(0xD800, 0xDFFF), false);
test_assert_equal(Uni_IsValid(0xE000, 0xFDCF), true);
test_assert_equal(Uni_IsValid(0xFDD0, 0xFDEF), false);
test_assert_equal(Uni_IsValid(0xFDF0, 0xFDFF), true);
test_assert_equal(Uni_IsValid(0xFDF0, 0xFFFD), true);
// negative range test
test_assert_equal(Uni_IsValid(0, 0x10FFFF), false); // ends with nonchar
test_assert_equal(Uni_IsValid(0, 0x10FFFD), false); // contains lots o' nonchars
test_assert_equal(Uni_IsValid(0x20, 0x10), false); // swapped
test_assert_equal(Uni_IsValid(0xFDEF, 0xFDF0), false); // just outside range
test_assert_equal(Uni_IsValid(0x0000, 0x010000), false); // crosses noncharacter plane boundary and other stuff
test_assert_equal(Uni_IsValid(0x010000, 0x020000), false); // crosses noncharacter plane boundary
test_assert_equal(Uni_IsValid(0x0000, 0xFFFF), false); // crosses other BMP prohibited and plane boundary
test_assert_equal(Uni_IsValid(0x0000, 0xFFFD), false); // crosses other BMP prohibited
test_assert_equal(Uni_IsValid(0x0000, 0xE000), false); // crosses surrogate space
test_assert_equal(Uni_IsValid(0x0000, 0x20FFFF), false); // out of bounds
test_assert_equal(Uni_IsValid(0x10FFFD, 0x20FFFF), false); // out of bounds
}
constexpr const auto help_str = u"\
test_kmx_xstring [--color]\n\
\n\
--color Force color output\n";
int error_args() {
std::cerr << u"test_kmx_xstring: Invalid arguments." << std::endl;
std::cout << help_str;
return 1;
}
int main(int argc, char *argv []) {
auto arg_color = argc > 1 && std::string(argv[1]) == "--color";
console_color::enabled = console_color::isaterminal() || arg_color;
test_incxstr();
test_decxstr();
test_xstrlen();
test_xstrlen_ignoreifopt();
test_utf32();
test_u16string_to_u32string();
test_is_valid();
return 0;
}
Reference in a new issue View git blame Copy permalink