#include "test.h"

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);
}

void
trie_optional_outputs_and_invalid_lengths(struct ct *t)
{
	char *v;
	Trie *trie;
	int n;

	trie = trieopen("data/trie.map");
	CT_CHECK(t, trieget(trie, "a", 1, nil) != nil);
	v = nil;
	CT_CHECK(t, trielookup(trie, "a", 1, &v, nil));
	CT_CHECK(t, v != nil);
	n = -1;
	CT_CHECK(t, trielookup(trie, "a", 1, nil, &n));
	CT_EQ_INT(t, 5, n);
	CT_CHECK(t, trielookup(trie, "dupli", 5, nil, nil));
	CT_EQ_PTR(t, nil, trieget(trie, nil, 1, &n));
	CT_EQ_PTR(t, nil, trieget(trie, "a", -1, &n));
	CT_CHECK(t, !trielookup(trie, nil, 1, &v, &n));
	CT_CHECK(t, !trielookup(trie, "a", -1, &v, &n));
	trieclose(trie);
}

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;
	Trie *fixture, *saved;
	int i;

	fixture = trieopen("data/hira.map");
	memset(&state, 0, sizeof state);
	state.l = getlang(LangJP);
	saved = state.l->map;
	state.l->map = fixture;
	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);
	}
	trieclose(fixture);
	state.l->map = saved;
}