void
lexicon_init (void)
{
Ustr *lexicons_path;
FILE *lexicons;
Ustr *line;
AUstr words;
lexicons_path = ustr_dup (cmdline_pkgdatadir ());
if (!lexicons_path)
abort ();
if (!ustr_add_cstr (&lexicons_path, "/lexicons"))
abort ();
line = ustr_dup_empty ();
if (!line)
abort ();
austr_init (&words);
lexicons = fopen (ustr_cstr (lexicons_path), "r");
if (!lexicons)
abort ();
lexicon_list = 0;
while (errno = 0, ustr_sc_del (&line), ustr_io_getline (&line, lexicons))
{
unsigned int i;
wordsplit (&words, line);
for (i = 0; i < austr_length (&words); ++i)
{
LexiconList *nlist;
nlist = malloc (sizeof (LexiconList));
if (!nlist)
abort ();
nlist->name = ustr_dup (austr_i (&words, i));
nlist->lexicon = 0;
nlist->next = lexicon_list;
lexicon_list = nlist;
}
}
if (errno != 0)
{
perror ("galcry-backend, lexicons");
fclose (lexicons);
abort ();
}
fclose (lexicons);
austr_deinit (&words);
ustr_sc_free (&lexicons_path);
}
int tst(void)
{
Ustr *s3 = ustr_dup_cstr("abcdefg xxxx xxxx xxxx xxxx1234yyyy yyyy yyyy zzz");
Ustr *s4 = NULL;
Ustr *s5 = NULL;
ASSERT(s3);
ASSERT(ustr_spn_cstr_fwd(s3, 0, "abcd") == 4);
ASSERT(ustr_spn_cstr_fwd(s3, 0, "abcdefg ") == 8);
ASSERT(ustr_spn_cstr_fwd(s3, 0, "abcdefg x") == 27);
ASSERT(ustr_cspn_cstr_fwd(s3, 0, "x") == 8);
ASSERT(ustr_cspn_cstr_fwd(s3, 0, "21") == 27);
ASSERT(ustr_spn_cstr_rev(s3, 0, "z") == 3);
ASSERT(ustr_spn_cstr_rev(s3, 0, "az") == 3);
ASSERT(ustr_spn_cstr_rev(s3, 0, "ayz") == 3);
ASSERT(ustr_spn_cstr_rev(s3, 0, "ayz ") == 18);
ASSERT(ustr_cspn_cstr_rev(s3, 0, "34") == 18);
ASSERT(ustr_cspn_cstr_rev(s3, 0, " ") == 3);
ASSERT(ustr_cspn_cstr_rev(s3, 0, "x") == 22);
ASSERT(ustr_spn_cstr_fwd(s3, 0, " xayzafg1234bcde ") == ustr_len(s3));
ASSERT(ustr_spn_cstr_rev(s3, 0, "1234abcdefg xayz ") == ustr_len(s3));
ASSERT(ustr_cspn_cstr_fwd(s3, 0, "!") == ustr_len(s3));
ASSERT(ustr_cspn_cstr_rev(s3, 0, "!") == ustr_len(s3));
ASSERT(ustr_cspn_cstr_fwd(s3, 0, "!@#") == ustr_len(s3));
ASSERT(ustr_cspn_cstr_rev(s3, 0, "!@#") == ustr_len(s3));
ASSERT((s4 = ustr_dup_subustr(s3, 1,
ustr_spn_cstr_fwd(s3, 0, "abcdefg "))));
ASSERT(ustr_del_subustr(&s3, 1, ustr_len(s4)));
ASSERT((s5 = ustr_dup(s4)));
ASSERT((s5 = ustr_dup(s4)));
ASSERT(ustr_set_subustr(&s5, s3, 1, ustr_spn_cstr_fwd(s3, 0, "x ")));
ASSERT(ustr_del_subustr(&s3, 1, ustr_len(s5)));
ASSERT(ustr_spn_cstr_fwd(s4, 0, "abcd") == 4);
ASSERT(ustr_spn_cstr_fwd(s4, 0, "abcdefg ") == 8);
ASSERT(ustr_spn_cstr_fwd(s4, 1, "abcdefg ") == 7);
ASSERT(ustr_spn_cstr_fwd(s4, 2, "abcdefg ") == 6);
ASSERT(ustr_spn_cstr_fwd(s4, 3, "abcdefg ") == 5);
ASSERT(ustr_spn_cstr_fwd(s4, 4, "abcdefg ") == 4);
ASSERT(ustr_spn_cstr_fwd(s4, 5, "abcdefg ") == 3);
ASSERT(ustr_spn_cstr_fwd(s4, 6, "abcdefg ") == 2);
ASSERT(ustr_spn_cstr_fwd(s4, 7, "abcdefg ") == 1);
ASSERT(ustr_spn_cstr_fwd(s4, 8, "abcdefg ") == 0);
ASSERT(ustr_spn_cstr_rev(s3, 0, "z") == 3);
ASSERT(ustr_spn_cstr_rev(s3, 4, "y") == 4);
ASSERT(ustr_spn_cstr_rev(s3, 0, "az") == 3);
ASSERT(ustr_spn_cstr_rev(s3, 0, "ayz") == 3);
ASSERT(ustr_spn_cstr_rev(s3, 0, "ayz ") == 18);
ASSERT(ustr_spn_cstr_rev(s3, 0, "y ") == 0);
ASSERT(ustr_spn_cstr_rev(s3, 1, "y ") == 0);
ASSERT(ustr_spn_cstr_rev(s3, 2, "y ") == 0);
ASSERT(ustr_spn_cstr_rev(s3, 3, "y ") == 15);
ASSERT(ustr_spn_cstr_rev(s3, 4, "y ") == 14);
ASSERT(ustr_spn_cstr_rev(s3, 5, "y ") == 13);
ASSERT(ustr_spn_cstr_rev(s3, 6, "y ") == 12);
ASSERT(ustr_spn_cstr_rev(s3, 7, "y ") == 11);
ASSERT(ustr_spn_cstr_rev(s3, 8, "y ") == 10);
ASSERT(ustr_spn_cstr_rev(s3, 9, "y ") == 9);
ASSERT(ustr_cspn_cstr_fwd(s4, 0, "e") == 4);
ASSERT(ustr_cspn_cstr_fwd(s4, 0, "!-") == 8);
ASSERT(ustr_cspn_cstr_fwd(s4, 1, "!-") == 7);
ASSERT(ustr_cspn_cstr_fwd(s4, 2, "!-") == 6);
ASSERT(ustr_cspn_cstr_fwd(s4, 3, "!-") == 5);
ASSERT(ustr_cspn_cstr_fwd(s4, 4, "!-") == 4);
ASSERT(ustr_cspn_cstr_fwd(s4, 5, "!-") == 3);
ASSERT(ustr_cspn_cstr_fwd(s4, 6, "!-") == 2);
ASSERT(ustr_cspn_cstr_fwd(s4, 7, "!-") == 1);
ASSERT(ustr_cspn_cstr_fwd(s4, 8, "!-") == 0);
ASSERT(ustr_cspn_cstr_fwd(s4, 0, "!") == 8);
ASSERT(ustr_cspn_cstr_fwd(s4, 1, "!") == 7);
ASSERT(ustr_cspn_cstr_fwd(s4, 2, "!") == 6);
ASSERT(ustr_cspn_cstr_fwd(s4, 3, "!") == 5);
ASSERT(ustr_cspn_cstr_fwd(s4, 4, "!") == 4);
ASSERT(ustr_cspn_cstr_fwd(s4, 5, "!") == 3);
ASSERT(ustr_cspn_cstr_fwd(s4, 6, "!") == 2);
ASSERT(ustr_cspn_cstr_fwd(s4, 7, "!") == 1);
ASSERT(ustr_cspn_cstr_fwd(s4, 8, "!") == 0);
ASSERT(ustr_cspn_cstr_rev(s4, 0, "e") == 3);
ASSERT(ustr_cspn_cstr_rev(s4, 0, "!-") == 8);
ASSERT(ustr_cspn_cstr_rev(s4, 1, "!-") == 7);
ASSERT(ustr_cspn_cstr_rev(s4, 2, "!-") == 6);
ASSERT(ustr_cspn_cstr_rev(s4, 3, "!-") == 5);
ASSERT(ustr_cspn_cstr_rev(s4, 4, "!-") == 4);
ASSERT(ustr_cspn_cstr_rev(s4, 5, "!-") == 3);
ASSERT(ustr_cspn_cstr_rev(s4, 6, "!-") == 2);
ASSERT(ustr_cspn_cstr_rev(s4, 7, "!-") == 1);
ASSERT(ustr_cspn_cstr_rev(s4, 8, "!-") == 0);
ASSERT(ustr_cspn_cstr_rev(s4, 0, "!") == 8);
ASSERT(ustr_cspn_cstr_rev(s4, 1, "!") == 7);
ASSERT(ustr_cspn_cstr_rev(s4, 2, "!") == 6);
ASSERT(ustr_cspn_cstr_rev(s4, 3, "!") == 5);
ASSERT(ustr_cspn_cstr_rev(s4, 4, "!") == 4);
ASSERT(ustr_cspn_cstr_rev(s4, 5, "!") == 3);
ASSERT(ustr_cspn_cstr_rev(s4, 6, "!") == 2);
ASSERT(ustr_cspn_cstr_rev(s4, 7, "!") == 1);
ASSERT(ustr_cspn_cstr_rev(s4, 8, "!") == 0);
ASSERT(ustr_cspn_cstr_rev(s3, 0, "34") == 18);
ASSERT(ustr_cspn_cstr_rev(s3, 0, " ") == 3);
ASSERT(ustr_cspn_cstr_rev(s3, 0, "x") == 22);
ASSERT(ustr_spn_cstr_fwd(s3, 0, "1") == 1);
ASSERT(ustr_spn_cstr_fwd(s3, 0, "12") == 2);
ASSERT(ustr_spn_cstr_fwd(s3, 0, "123") == 3);
ASSERT(ustr_spn_cstr_fwd(s3, 0, "1234") == 4);
ASSERT(ustr_spn_cstr_fwd(s3, 0, "1234y") == 8);
ASSERT(ustr_del_subustr(&s3, 4, 4));
ASSERT(ustr_spn_cstr_fwd(s3, 0, "1234y") == 4);
ustr_free(s3);
ustr_free(s4); /* leaked, see above */
ustr_free(s4);
ustr_free(s5);
return (EXIT_SUCCESS);
}
int tst(void)
{
size_t end = USTR__SIZE_MAX;
size_t large = 1;
size_t small = 4096;
size_t num = 0;
Ustr *s3 = USTR1(\3, "124");
ASSERT((s1 = ustr_dupx_empty(0, 0, 0, 0)));
ASSERT(ustr_size_alloc(s1) > 0);
/* max 32bit overhead */
while (num < (1 + 4 + sizeof(USTR_END_ALOCDx)))
{
ASSERT(!ustr_add_undef(&s1, end - num));
ASSERT(!ustr_dup_undef( end - num));
ASSERT(!ustr_ins_undef(&s3, 1, end - num));
ASSERT(!ustr_set_undef(&s1, end - num));
++num;
}
while (num < (1 + 4 + sizeof(USTR_END_ALOCDx) + ustr_len(s3)))
{
ASSERT(!ustr_ins_undef(&s3, 1, end - num));
++num;
}
num = (1 + 4 + sizeof(USTR_END_ALOCDx));
if (!USTR_CONF_HAVE_64bit_SIZE_MAX)
{
big_tst(small, end, USTR_TRUE, USTR_TRUE);
big_tst( 0, end, USTR_TRUE, USTR_TRUE);
return (EXIT_FAILED_OK);
}
/* max 64bit overhead */
while (num < (1 + 2 + 8 + 8 + sizeof(USTR_END_ALOCDx)))
{
ASSERT(!ustr_add_undef(&s1, end - num));
ASSERT(!ustr_dup_undef( end - num));
ASSERT(!ustr_ins_undef(&s3, 1, end - num));
ASSERT(!ustr_set_undef(&s1, end - num));
++num;
}
while (num < (1 + 2 + 8 + 8 + sizeof(USTR_END_ALOCDx) + ustr_len(s3)))
{
ASSERT(!ustr_ins_undef(&s3, 1, end - num));
++num;
}
ustr_free(s1);
if (USTR_CONF_USE_DYNAMIC_CONF)
{
assert(ustr_cntl_opt(USTR_CNTL_OPT_SET_REF_BYTES, 8));
assert(ustr_cntl_opt(USTR_CNTL_OPT_SET_HAS_SIZE, 0));
ASSERT((s1 = ustr_dupx_undef(0, 8, 0, 0, 0)));
ASSERT(ustr_ro(s1));
ASSERT((s1 = ustr_dupx_undef(1, 8, 0, 0, 0)));
ASSERT(ustr_ro(s1));
}
ASSERT((s1 = ustr_dupx_empty(0, 8, USTR_FALSE, USTR_FALSE)));
ASSERT(ustr_sized(s1));
ASSERT(ustr_size_alloc(s1) >= 14);
ASSERT(ustr_size_overhead(s1) >= 14);
ustr_free(ustr_dup(s1));
big_tst(small, end, USTR_TRUE, USTR_TRUE);
big_tst( 0, end, USTR_TRUE, USTR_TRUE);
large *= 1024;
large *= 1024;
large *= 1024;
large *= 9;
return (big_tst(0, large, USTR_FALSE, USTR_FALSE));
}
void
lexicon_generate (Ustr **s, Ustr const *language)
{
LexiconList *sp;
char ch[2];
ustr_sc_del (s);
ch[0] = 0;
ch[1] = 0;
/* Linear search. Simple and we don't expect dozens of lexicons
anyway. */
sp = lexicon_list;
while (sp && !ustr_cmp_eq (language, sp->name))
sp = sp->next;
if (!sp)
return;
/* Load lexicon if not existent yet. */
if (!sp->lexicon)
{
Ustr *path;
path = ustr_dup (cmdline_pkgdatadir ());
if (!path)
abort ();
if (!ustr_add_cstr (&path, "/lexicon/"))
abort ();
if (!ustr_add (&path, sp->name))
abort ();
sp->lexicon = learn (path);
ustr_sc_free (&path);
}
/* Generate. */
{
unsigned int c0, c1, c2;
unsigned long int sel;
unsigned long int lim;
unsigned int i;
Lexicon *l;
c0 = 0;
l = sp->lexicon;
/* Generate first char. */
for (i = 1, lim = 0; i < 27; ++i)
lim += l->histogram2[0][i];
/* Random select. */
sel = random () % lim;
/* Find histogram area that random selection got in. */
for (c1 = 1; sel >= l->histogram2[0][c1]; ++c1)
sel -= l->histogram2[0][c1];
/* Add random selection. */
ch[0] = 96 + c1;
if (!ustr_add_cstr (s, ch))
abort ();
/* Generate subsequent chars. */
do
{
/* Random select. */
sel = random () % l->histogram2[c0][c1];
for (c2 = 0; sel >=l->histogram3[c0][c1][c2]; ++c2)
sel -= l->histogram3[c0][c1][c2];
if (c2 != 0)
{
ch[0] = 96 + c2;
if (!ustr_add_cstr (s, ch))
abort ();
}
c0 = c1;
c1 = c2;
}
while (c2 != 0);
}
}
int tst(void)
{
struct Ustr *s3 = NULL;
struct Ustr *s4 = NULL;
assert(!USTR_CONF_USE_DYNAMIC_CONF ||
ustr_cntl_opt(USTR_CNTL_OPT_SET_REF_BYTES, 1));
/* move to the new "default" conf */
ustr_sc_free2(&s2, ustr_dup_buf(ustr_cstr(s2), ustr_len(s2)));
ASSERT(s2);
s3 = ustr_dup_cstr("s3 abcd s2");
s4 = ustr_dup_rep_chr('x', 40);
ASSERT(s3);
ASSERT(s4);
ASSERT(ustr_len(s1) == 0);
ASSERT(ustr_len(s2) == 2);
ASSERT(ustr_len(s3) == 10);
ASSERT(ustr_len(s4) == 40);
ASSERT(ustr_size(s1) == 0);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s2) == 2); /* ustr__ns(1 + 1 + 1 + 2 + 1) -
* 1 + 1 + 1 + 1 */
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s3) == 12); /* ustr__ns(1 + 1 + 1 + 10 + 1) -
* 1 + 1 + 1 + 1 */
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s4) == 44);
ASSERT(ustr_add_rep_chr(&s4, '-', 8));
ASSERT(ustr_len(s4) == 48);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s4) == 60);
ASSERT(ustr_del(&s4, 4));
ASSERT(ustr_len(s4) == 44);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s4) == 44);
ASSERT(ustr_del(&s4, 20));
ASSERT(ustr_len(s4) == 24);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s4) == 28);
ustr_sc_free(&s3);
ASSERT((s3 = ustr_dup(s4)));
ASSERT(ustr_len(s3) == 24);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s3) == 28);
ASSERT(ustr_len(s4) == 24);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s4) == 28);
ASSERT(ustr_del(&s4, 15));
ASSERT(ustr_len(s3) == 24);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s3) == 28);
ASSERT(ustr_len(s4) == 9);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s4) == 12);
ASSERT(ustr_cmp_cstr_eq(s3, "xxxxxxxxxxxxxxxxxxxxxxxx"));
ASSERT(!strcmp(ustr_cstr(s3), "xxxxxxxxxxxxxxxxxxxxxxxx"));
ASSERT(ustr_cmp_cstr_eq(s4, "xxxxxxxxx"));
ASSERT(!strcmp(ustr_cstr(s4), "xxxxxxxxx"));
ASSERT(!ustr_del(&s4, 15));
ASSERT(ustr_del(&s4, 8));
ASSERT(ustr_len(s4) == 1);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s4) == 2);
ASSERT(ustr_cmp_cstr_eq(s4, "x"));
ASSERT(!strcmp(ustr_cstr(s4), "x"));
ASSERT(ustr_add_rep_chr(&s4, '-', 8));
ASSERT(ustr_len(s4) == 9);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s4) == 12);
ASSERT(ustr_cmp_cstr_eq(s4, "x--------"));
ASSERT(!strcmp(ustr_cstr(s4), "x--------"));
ASSERT(ustr_set_cstr(&s4, "x12345678"));
ustr_sc_free2(&s3, s4);
ASSERT(ustr_cmp_cstr_eq(s4, "x12345678"));
ASSERT( ustr_owner(s4));
ASSERT(!ustr_shared(s4));
ASSERT(s3 == s4);
ASSERT( ustr_setf_share(s4));
ASSERT(!ustr_owner(s4));
ASSERT(ustr_del_subustr(&s4, 4, 4));
ASSERT(ustr_cmp_cstr_eq(s3, "x12345678"));
ASSERT(ustr_cmp_cstr_eq(s4, "x1278"));
ustr_sc_free_shared(&s3);
ustr_sc_free(&s4);
return (EXIT_SUCCESS);
}
int tst(void)
{
struct Ustr *s3 = NULL;
struct Ustr *s4 = NULL;
int num = -1;
assert(!USTR_CONF_USE_DYNAMIC_CONF ||
ustr_cntl_opt(USTR_CNTL_OPT_SET_REF_BYTES, 1));
/* move to the new "default" conf */
ustr_sc_free2(&s2, ustr_dup_buf(ustr_cstr(s2), ustr_len(s2)));
s3 = ustr_dup_cstr("s3 abcd s2");
s4 = ustr_dup_empty(); /* always allocs */
ASSERT(s2);
ASSERT(s3);
ASSERT(s4);
ASSERT(ustr_cmp_eq(s1, s4));
ASSERT(ustr_len(s1) == 0);
ASSERT(ustr_len(s2) == 2);
ASSERT(ustr_len(s3) == 10);
ASSERT(ustr_len(s4) == 0);
ASSERT(ustr_size(s1) == 0);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s2) == 2);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s3) == 12);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s4) == 0);
ASSERT(ustr_srch_fwd(s3, 0, s2) == 9);
ASSERT(ustr_srch_rev(s3, 0, s2) == 9);
ASSERT(ustr_srch_fwd(s2, 0, s3) == 0);
ASSERT(ustr_srch_rev(s2, 0, s3) == 0);
ASSERT(ustr_add_cstr(&s2, "x"));
ASSERT(ustr_len(s2) == 3);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s2) == 4);
ASSERT(ustr_add_cstr(&s2, "y"));
ASSERT(ustr_len(s2) == 4);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s2) == 4);
ASSERT(ustr_add_cstr(&s2, "z"));
ASSERT(ustr_len(s2) == 5);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s2) == 8);
ASSERT(ustr_add_rep_chr(&s2, '-', 11));
ASSERT(ustr_len(s2) == 16);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s2) == 20);
ASSERT(ustr_cmp_cstr_eq(s2, "s2xyz-----------"));
ASSERT(!strcmp(ustr_cstr(s2), "s2xyz-----------"));
ASSERT(ustr_srch_fwd(s3, 0, s2) == 0);
ASSERT(ustr_srch_rev(s3, 0, s2) == 0);
ASSERT(ustr_srch_fwd(s2, 0, s3) == 0);
ASSERT(ustr_srch_rev(s2, 0, s3) == 0);
/* NOTE: Using system *printf, so can't use %zu as Solaris is retarded */
ASSERT(ustr_add_fmt(&s1, "%s abcd %13.100s %d %c %lu%n",
"------abc------", "", 42, 0,
(unsigned long)ustr_len(s3), &num) != -1);
ASSERT((unsigned)num == ustr_len(s1));
ASSERT(42 == num);
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(44 == ustr_size(s1));
ASSERT(ustr_add_fmt(&s4, "%2$d%1$u", 2, 4));
ASSERT(ustr_srch_cstr_fwd(s1, 0, "abcd") == 17);
ASSERT(ustr_srch_cstr_rev(s1, 0, "abcd") == 17);
ASSERT(ustr_srch_cstr_fwd(s1, 0, "abc") == 7);
ASSERT(ustr_srch_cstr_rev(s1, 0, "abc") == 17);
ASSERT(ustr_srch_cstr_fwd(s1, 0, "10") == 41);
ASSERT(ustr_srch_cstr_rev(s1, 0, "10") == 41);
ASSERT(ustr_srch_chr_fwd(s1, 0, 0) == 39);
ASSERT(ustr_srch_chr_rev(s1, 0, 0) == 39);
ASSERT(ustr_srch_fwd(s1, 0, s4) == 36);
ASSERT(ustr_srch_cstr_fwd(s1, 1, "abcd") == 17);
ASSERT(ustr_srch_cstr_rev(s1, 1, "abcd") == 17);
ASSERT(ustr_srch_cstr_fwd(s1, 10, "abcd") == 17);
ASSERT(ustr_srch_cstr_rev(s1, 10, "abcd") == 17);
ASSERT(ustr_srch_cstr_fwd(s1, 0, " ") == 16);
ASSERT(ustr_srch_cstr_fwd(s1, 10, " ") == 16);
ASSERT(ustr_srch_cstr_fwd(s1, 16, " ") == 21);
ASSERT(ustr_srch_cstr_fwd(s1, 20, " ") == 21);
ASSERT(ustr_srch_cstr_fwd(s1, 21, " ") == 22);
ASSERT(ustr_srch_rep_chr_fwd(s1, 21, ' ', 1) == 22);
ASSERT(ustr_srch_cstr_fwd(s1, 21, " ") == 22);
ASSERT(ustr_srch_rep_chr_fwd(s1, 21, ' ', 2) == 22);
ASSERT(ustr_srch_cstr_fwd(s1, 21, " ") == 22);
ASSERT(ustr_srch_rep_chr_fwd(s1, 21, ' ', 3) == 22);
ASSERT(ustr_srch_cstr_fwd(s1, 21, " ") == 22);
ASSERT(ustr_srch_rep_chr_fwd(s1, 21, ' ', 4) == 22);
ASSERT(ustr_srch_cstr_fwd(s1, 21, " ") == 22);
ASSERT(ustr_srch_rep_chr_fwd(s1, 21, ' ', 5) == 22);
ASSERT(ustr_srch_cstr_fwd(s1, 0, "a") == 7);
ASSERT(ustr_srch_cstr_fwd(s1, 6, "a") == 7);
ASSERT(ustr_srch_cstr_fwd(s1, 7, "a") == 17);
ASSERT(ustr_srch_cstr_fwd(s1, 16, "a") == 17);
ASSERT(ustr_srch_cstr_fwd(s1, 17, "a") == 0);
ASSERT(ustr_srch_cstr_rev(s1, 0, "a") == 17);
ASSERT(ustr_srch_cstr_rev(s1, ustr_len(s1) - 17, "a") == 17);
ASSERT(ustr_srch_cstr_rev(s1, ustr_len(s1) - 16, "a") == 7);
ASSERT(ustr_srch_cstr_rev(s1, ustr_len(s1) - 7, "a") == 7);
ASSERT(ustr_srch_cstr_rev(s1, ustr_len(s1) - 6, "a") == 0);
ASSERT(ustr_srch_cstr_rev(s1, ustr_len(s1) - 1, "a") == 0);
/* srch_case */
ASSERT(ustr_srch_case_cstr_fwd(s1, 0, " ") == 16);
ASSERT(ustr_srch_case_cstr_fwd(s1, 10, " ") == 16);
ASSERT(ustr_srch_case_cstr_fwd(s1, 16, " ") == 21);
ASSERT(ustr_srch_case_cstr_fwd(s1, 20, " ") == 21);
ASSERT(ustr_srch_case_cstr_fwd(s1, 21, " ") == 22);
ASSERT(ustr_srch_case_rep_chr_fwd(s1, 21, ' ', 1) == 22);
ASSERT(ustr_srch_case_cstr_fwd(s1, 21, " ") == 22);
ASSERT(ustr_srch_case_rep_chr_fwd(s1, 21, ' ', 2) == 22);
ASSERT(ustr_srch_case_cstr_fwd(s1, 21, " ") == 22);
ASSERT(ustr_srch_case_rep_chr_fwd(s1, 21, ' ', 3) == 22);
ASSERT(ustr_srch_case_cstr_fwd(s1, 21, " ") == 22);
ASSERT(ustr_srch_case_rep_chr_fwd(s1, 21, ' ', 4) == 22);
ASSERT(ustr_srch_case_cstr_fwd(s1, 21, " ") == 22);
ASSERT(ustr_srch_case_rep_chr_fwd(s1, 21, ' ', 5) == 22);
ASSERT(ustr_srch_case_cstr_fwd(s1, 0, "a") == 7);
ASSERT(ustr_srch_case_cstr_fwd(s1, 6, "a") == 7);
ASSERT(ustr_srch_case_cstr_fwd(s1, 7, "a") == 17);
ASSERT(ustr_srch_case_cstr_fwd(s1, 16, "a") == 17);
ASSERT(ustr_srch_case_cstr_fwd(s1, 17, "a") == 0);
ASSERT(ustr_srch_case_cstr_fwd(s1, 0, "A") == 7);
ASSERT(ustr_srch_case_cstr_fwd(s1, 6, "A") == 7);
ASSERT(ustr_srch_case_cstr_fwd(s1, 7, "A") == 17);
ASSERT(ustr_srch_case_cstr_fwd(s1, 16, "A") == 17);
ASSERT(ustr_srch_case_cstr_fwd(s1, 17, "A") == 0);
ASSERT(ustr_srch_case_cstr_rev(s1, 0, "a") == 17);
ASSERT(ustr_srch_case_cstr_rev(s1, ustr_len(s1) - 17, "a") == 17);
ASSERT(ustr_srch_case_cstr_rev(s1, ustr_len(s1) - 16, "a") == 7);
ASSERT(ustr_srch_case_cstr_rev(s1, ustr_len(s1) - 7, "a") == 7);
ASSERT(ustr_srch_case_cstr_rev(s1, ustr_len(s1) - 6, "a") == 0);
ASSERT(ustr_srch_case_cstr_rev(s1, ustr_len(s1) - 1, "a") == 0);
ASSERT(ustr_srch_case_cstr_rev(s1, 0, "A") == 17);
ASSERT(ustr_srch_case_cstr_rev(s1, ustr_len(s1) - 17, "A") == 17);
ASSERT(ustr_srch_case_cstr_rev(s1, ustr_len(s1) - 16, "A") == 7);
ASSERT(ustr_srch_case_cstr_rev(s1, ustr_len(s1) - 7, "A") == 7);
ASSERT(ustr_srch_case_cstr_rev(s1, ustr_len(s1) - 6, "A") == 0);
ASSERT(ustr_srch_case_cstr_rev(s1, ustr_len(s1) - 1, "A") == 0);
if (!USTR_DEBUG)
ASSERT(ustr_srch_cstr_fwd(s1, ustr_len(s1), "a") == 0);
if (!USTR_DEBUG)
ASSERT(ustr_srch_cstr_rev(s1, ustr_len(s1), "a") == 0);
/* puts(ustr_cstr(s4)); */
ustr_sc_free(&s3);
ASSERT((s3 = ustr_dup(s4)));
ASSERT(ustr_add_fmt(&s4, "x"));
ustr_sc_free(&s4);
ustr_sc_free(&s3);
/*
ASSERT(!ustr_assert_valid(USTR1(\x000F, "123456789 123456")));
ASSERT(!ustr_assert_valid(USTR1(\x000F, "123456789 1234\0xxx"))); */
ASSERT( ustr_assert_valid(USTR1(\x000F, "123456789 12345")));
/* ASSERT(!ustr_assert_valid(USTR1(\x000F, "123456789 12345\0xxx"))); */
s3 = ustr_dupx(0, 2, 0, 1, USTR1(\x000F, "123456789 12345"));
ASSERT(ustr_cmp_cstr_eq(s3, "123456789 12345"));
ASSERT(ustr_cmp_eq(s3, USTR1(\x000F, "123456789 12345")));
ASSERT(!ustr_ro(s3));
if (!USTR_CONF_USE_EOS_MARK)
ASSERT(ustr_size(s3) == 19);
ustr_sc_free(&s3);
return (EXIT_SUCCESS);
}
