127 lines
2.6 KiB
C
127 lines
2.6 KiB
C
#include "test.h"
|
|
|
|
static void
|
|
checkcrlf(struct ct *t)
|
|
{
|
|
static char data[] = "crlf\tvalue\r\n";
|
|
char path[80], *v;
|
|
Trie *trie;
|
|
int fd, n;
|
|
|
|
snprint(path, sizeof path, "/tmp/strans-crlf-%d.map", getpid());
|
|
remove(path);
|
|
fd = create(path, OWRITE, 0600);
|
|
if(fd < 0){
|
|
CT_ERRORF(t, "cannot create CRLF fixture");
|
|
return;
|
|
}
|
|
if(write(fd, data, sizeof data - 1) != (long)(sizeof data - 1)){
|
|
CT_ERRORF(t, "cannot write CRLF fixture");
|
|
close(fd);
|
|
remove(path);
|
|
return;
|
|
}
|
|
close(fd);
|
|
trie = trieopen(path);
|
|
remove(path);
|
|
v = trieget(trie, "crlf", 4, &n);
|
|
if(CT_CHECK(t, v != nil)){
|
|
CT_EQ_INT(t, 5, n);
|
|
CT_EQ_MEM(t, "value", v, n);
|
|
}
|
|
trieclose(trie);
|
|
}
|
|
|
|
void
|
|
trie_exact_prefix_and_duplicate(struct ct *t)
|
|
{
|
|
char *v, *sentinel;
|
|
Trie *trie;
|
|
int n;
|
|
|
|
trie = trieopen("data/trie.map");
|
|
v = trieget(trie, "a", 1, &n);
|
|
if(!CT_CHECK(t, v != nil))
|
|
goto cleanup;
|
|
CT_EQ_INT(t, 5, n);
|
|
CT_EQ_MEM(t, "alpha", v, n);
|
|
sentinel = "unchanged";
|
|
v = sentinel;
|
|
n = 77;
|
|
CT_CHECK(t, trielookup(trie, "dupli", 5, &v, &n));
|
|
CT_EQ_PTR(t, sentinel, v);
|
|
CT_EQ_INT(t, 77, n);
|
|
v = trieget(trie, "duplicate", 9, &n);
|
|
if(!CT_CHECK(t, v != nil))
|
|
goto cleanup;
|
|
CT_EQ_INT(t, 6, n);
|
|
CT_EQ_MEM(t, "second", v, n);
|
|
v = trieget(trie, "tabs", 4, &n);
|
|
if(!CT_CHECK(t, v != nil))
|
|
goto cleanup;
|
|
CT_EQ_INT(t, 7, n);
|
|
CT_EQ_MEM(t, "one\ttwo", v, n);
|
|
CT_EQ_PTR(t, nil, trieget(trie, "missing", 7, &n));
|
|
cleanup:
|
|
trieclose(trie);
|
|
checkcrlf(t);
|
|
}
|
|
|
|
void
|
|
production_maps_load(struct ct *t)
|
|
{
|
|
char path[256];
|
|
Trie *map;
|
|
int i, loaded, registered;
|
|
|
|
loaded = registered = 0;
|
|
for(i = 0; i < nlang; i++){
|
|
if(langs[i].mapname == nil)
|
|
continue;
|
|
registered++;
|
|
snprint(path, sizeof path, "../map/%s.map", langs[i].mapname);
|
|
map = trieopen(path);
|
|
if(!CT_CHECK(t, map != nil))
|
|
continue;
|
|
trieclose(map);
|
|
loaded++;
|
|
}
|
|
CT_CHECK(t, registered > 0);
|
|
CT_EQ_INT(t, registered, loaded);
|
|
}
|
|
|
|
void
|
|
transmap_states(struct ct *t)
|
|
{
|
|
static const struct {
|
|
char *pre;
|
|
Rune key;
|
|
int eat;
|
|
char *emit;
|
|
char *next;
|
|
char *mapped;
|
|
} cases[] = {
|
|
{ "", 'k', 1, "", "k", "" },
|
|
{ "k", 'a', 1, "", "ka", "か" },
|
|
{ "ka", 's', 1, "か", "s", "" },
|
|
{ "ka", 'q', 0, "か", "", "" },
|
|
{ "k", 'q', 0, "k", "", "" },
|
|
};
|
|
Emit e;
|
|
Im state;
|
|
int i;
|
|
|
|
memset(&state, 0, sizeof state);
|
|
state.l = getlang(LangJP);
|
|
for(i = 0; i < nelem(cases); i++){
|
|
state.pre = mkstr(cases[i].pre);
|
|
e = transmap(&state, cases[i].key);
|
|
if(e.eat != cases[i].eat)
|
|
CT_ERRORF(t, "case %d: want eat %d, got %d",
|
|
i, cases[i].eat, e.eat);
|
|
checkstr(t, "emit", cases[i].emit, &e.s);
|
|
checkstr(t, "next", cases[i].next, &e.next);
|
|
checkstr(t, "mapped", cases[i].mapped, &e.dict);
|
|
}
|
|
}
|