package dict_test
import (
"encoding/binary"
"io"
"os"
"path/filepath"
"slices"
"strings"
"testing"
"chirami/internal/dict"
"chirami/internal/dict/build"
)
func buildTestDict(t *testing.T, includeNames bool) *dict.Dict {
t.Helper()
jmdictFile, err := os.Open("testdata/jmdict.json")
if err != nil {
t.Fatalf("open jmdict.json: %v", err)
}
defer jmdictFile.Close()
kanjidicFile, err := os.Open("testdata/kanjidic.json")
if err != nil {
t.Fatalf("open kanjidic.json: %v", err)
}
defer kanjidicFile.Close()
accentsFile, err := os.Open("testdata/accents.txt")
if err != nil {
t.Fatalf("open accents.txt: %v", err)
}
defer accentsFile.Close()
xmlFile, err := os.Open("testdata/jmdict.xml")
if err != nil {
t.Fatalf("open jmdict.xml: %v", err)
}
defer xmlFile.Close()
furiFile, err := os.Open("testdata/furigana.json")
if err != nil {
t.Fatalf("open furigana.json: %v", err)
}
defer furiFile.Close()
n5File, err := os.Open("testdata/jlpt_n5.csv")
if err != nil {
t.Fatalf("open jlpt_n5: %v", err)
}
defer n5File.Close()
n4File, err := os.Open("testdata/jlpt_n4.csv")
if err != nil {
t.Fatalf("open jlpt_n4: %v", err)
}
defer n4File.Close()
n1File, err := os.Open("testdata/jlpt_n1.csv")
if err != nil {
t.Fatalf("open jlpt_n1: %v", err)
}
defer n1File.Close()
opts := []build.BuildOption{
build.WithPriorities(xmlFile),
build.WithFurigana(furiFile),
build.WithJLPT(map[string]io.Reader{
"N5": n5File,
"N4": n4File,
"N1": n1File,
}),
}
kradFile, err := os.Open("testdata/kradfile.json")
if err == nil {
defer kradFile.Close()
opts = append(opts, build.WithKradfile(kradFile))
}
radkFile, err := os.Open("testdata/radkfile.json")
if err == nil {
defer radkFile.Close()
opts = append(opts, build.WithRadkfile(radkFile))
}
if includeNames {
namesFile, err := os.Open("testdata/jmnedict.json")
if err != nil {
t.Fatalf("open jmnedict.json: %v", err)
}
defer namesFile.Close()
opts = append(opts, build.WithNames(namesFile))
}
outPath := filepath.Join(t.TempDir(), "testdict.bin")
err = build.Build(jmdictFile, kanjidicFile, accentsFile, outPath, opts...)
if err != nil {
t.Fatalf("build test dict: %v", err)
}
d, err := dict.Open(outPath)
if err != nil {
t.Fatalf("open test dict: %v", err)
}
t.Cleanup(func() {
d.Close()
})
return d
}
func TestLookup(t *testing.T) {
d := buildTestDict(t, false)
// 1. Kanji lookup
taberuKanji := d.Lookup("食べる")
if len(taberuKanji) == 0 {
t.Fatalf("Lookup('食べる') returned 0 entries")
}
if taberuKanji[0].Kanji[0].Text != "食べる" {
t.Errorf("got %q, want '食べる'", taberuKanji[0].Kanji[0].Text)
}
// 2. Hiragana lookup matching kanji form's reading
taberuHira := d.Lookup("たべる")
if len(taberuHira) == 0 {
t.Fatalf("Lookup('たべる') returned 0 entries")
}
if taberuHira[0].ID != taberuKanji[0].ID {
t.Errorf("Lookup('たべる') ID %d != Lookup('食べる') ID %d", taberuHira[0].ID, taberuKanji[0].ID)
}
// 3. Katakana lookup matching hiragana reading
taberuKata := d.Lookup("タベル")
if len(taberuKata) == 0 {
t.Fatalf("Lookup('タベル') returned 0 entries")
}
if taberuKata[0].ID != taberuKanji[0].ID {
t.Errorf("Lookup('タベル') ID %d != Lookup('食べる') ID %d", taberuKata[0].ID, taberuKanji[0].ID)
}
// 4. Katakana-only entry
ramen := d.Lookup("ラーメン")
if len(ramen) == 0 {
t.Fatalf("Lookup('ラーメン') returned 0 entries")
}
if ramen[0].Kana[0].Text != "ラーメン" {
t.Errorf("got %q, want 'ラーメン'", ramen[0].Kana[0].Text)
}
// Hiragana matching katakana entry
ramenHira := d.Lookup("らーめん")
if len(ramenHira) == 0 {
t.Fatalf("Lookup('らーめん') returned 0 entries")
}
if ramenHira[0].ID != ramen[0].ID {
t.Errorf("Lookup('らーめん') ID %d != Lookup('ラーメン') ID %d", ramenHira[0].ID, ramen[0].ID)
}
// 5. Kana-only entry
kasakasa := d.Lookup("かさかさ")
if len(kasakasa) == 0 {
t.Fatalf("Lookup('かさかさ') returned 0 entries")
}
// 6. Particle は
ha := d.Lookup("は")
if len(ha) == 0 {
t.Fatalf("Lookup('は') returned 0 entries")
}
// 7. Non-existent entry
nonExistent := d.Lookup("存在しない単語xyz")
if len(nonExistent) != 0 {
t.Errorf("expected 0 entries for non-existent word, got %d", len(nonExistent))
}
}
func TestLookupPriorityRanking(t *testing.T) {
d := buildTestDict(t, false)
// "きょう": 今日 (ID 1579110, nf02) must beat 京 (ID 1233320, nf03)
entries := d.Lookup("きょう")
if len(entries) < 2 {
t.Fatalf("expected at least 2 entries for 'きょう', got %d", len(entries))
}
if entries[0].Kanji[0].Text != "今日" {
t.Fatalf("first entry for 'きょう' is %q (ID %d), want '今日' (ID 1579110)", entries[0].Kanji[0].Text, entries[0].ID)
}
if entries[1].Kanji[0].Text != "京" {
t.Errorf("second entry for 'きょう' is %q, want '京'", entries[1].Kanji[0].Text)
}
}
func TestJLPT(t *testing.T) {
d := buildTestDict(t, false)
// 今日 listed in both N5 and N4 -> N5 wins (easiest level)
kyo := d.Lookup("今日")
if len(kyo) == 0 {
t.Fatalf("Lookup('今日') empty")
}
if kyo[0].JLPT != "N5" {
t.Errorf("今日 JLPT = %q, want 'N5'", kyo[0].JLPT)
}
// 食べる in N5
taberu := d.Lookup("食べる")
if len(taberu) == 0 {
t.Fatalf("Lookup('食べる') empty")
}
if taberu[0].JLPT != "N5" {
t.Errorf("食べる JLPT = %q, want 'N5'", taberu[0].JLPT)
}
// 勉強 in N4
benkyo := d.Lookup("勉強")
if len(benkyo) == 0 {
t.Fatalf("Lookup('勉強') empty")
}
if benkyo[0].JLPT != "N4" {
t.Errorf("勉強 JLPT = %q, want 'N4'", benkyo[0].JLPT)
}
// 日本語 in N1
nihongo := d.Lookup("日本語")
if len(nihongo) == 0 {
t.Fatalf("Lookup('日本語') empty")
}
if nihongo[0].JLPT != "N1" {
t.Errorf("日本語 JLPT = %q, want 'N1'", nihongo[0].JLPT)
}
}
func TestNames(t *testing.T) {
d := buildTestDict(t, true)
// "きょう" has JMdict entries for 今日 and 京, and JMnedict name entry for surname "今日" (Kyou)
entries := d.Lookup("きょう")
if len(entries) < 3 {
t.Fatalf("expected at least 3 entries, got %d", len(entries))
}
// The first 2 entries must be JMdict entries (ID < 100000000)
if entries[0].ID >= 100000000 || entries[1].ID >= 100000000 {
t.Errorf("first entries should be JMdict, got ID %d and %d", entries[0].ID, entries[1].ID)
}
// The name entry must be ranked after all JMdict entries
var nameEntry *dict.Entry
for i := range entries {
if entries[i].ID >= 100000000 {
nameEntry = &entries[i]
break
}
}
if nameEntry == nil {
t.Fatalf("no name entry found in Lookup('きょう')")
}
if !slices.Contains(nameEntry.Senses[0].Misc, "surname") {
t.Errorf("name sense misc = %v, want 'surname'", nameEntry.Senses[0].Misc)
}
if !slices.Contains(nameEntry.Senses[0].Gloss, "Kyou") {
t.Errorf("name sense gloss = %v, want 'Kyou'", nameEntry.Senses[0].Gloss)
}
}
func TestLookupReading(t *testing.T) {
d := buildTestDict(t, false)
kyoEntries := d.LookupReading("今日", "きょう")
if len(kyoEntries) < 2 {
t.Fatalf("expected at least 2 entries for '今日', got %d", len(kyoEntries))
}
if kyoEntries[0].Kana[0].Text != "きょう" {
t.Errorf("first entry reading = %q, want 'きょう'", kyoEntries[0].Kana[0].Text)
}
konnichiEntries := d.LookupReading("今日", "こんにち")
if len(konnichiEntries) < 2 {
t.Fatalf("expected at least 2 entries for '今日', got %d", len(konnichiEntries))
}
if konnichiEntries[0].Kana[0].Text != "こんにち" {
t.Errorf("first entry reading = %q, want 'こんにち'", konnichiEntries[0].Kana[0].Text)
}
// Kana-only lookup ranks the particle は ahead of kanji homophone 葉 (nf03).
haEntries := d.LookupReading("は", "は")
if len(haEntries) < 2 {
t.Fatalf("expected at least 2 entries for 'は', got %d", len(haEntries))
}
if haEntries[0].ID != 2028920 {
t.Errorf("first entry for 'は' = ID %d (%v), want 2028920 (particle は)", haEntries[0].ID, haEntries[0].Kanji)
}
}
func TestLongestPrefix(t *testing.T) {
d := buildTestDict(t, false)
n, entries := d.LongestPrefix("日本語を勉強", 8)
expectedLen := len("日本語")
if n != expectedLen {
t.Errorf("LongestPrefix byte length = %d, want %d", n, expectedLen)
}
if len(entries) == 0 {
t.Fatalf("LongestPrefix returned 0 entries")
}
if entries[0].Kanji[0].Text != "日本語" {
t.Errorf("got %q, want '日本語'", entries[0].Kanji[0].Text)
}
n, entries = d.LongestPrefix("あいうえお", 3)
if n != 0 || entries != nil {
t.Errorf("expected 0, nil for no match, got %d, %v", n, entries)
}
}
func TestKanji(t *testing.T) {
d := buildTestDict(t, false)
k, ok := d.Kanji('食')
if !ok {
t.Fatalf("Kanji('食') not found")
}
if k.Literal != "食" {
t.Errorf("Literal = %q, want '食'", k.Literal)
}
if k.Strokes != 9 {
t.Errorf("Strokes = %d, want 9", k.Strokes)
}
if k.Grade != 2 {
t.Errorf("Grade = %d, want 2", k.Grade)
}
if !slices.Contains(k.Meanings, "eat") {
t.Errorf("Meanings %v does not contain 'eat'", k.Meanings)
}
if !slices.Contains(k.On, "ショク") {
t.Errorf("On %v does not contain 'ショク'", k.On)
}
if !slices.Contains(k.Kun, "た.べる") {
t.Errorf("Kun %v does not contain 'た.べる'", k.Kun)
}
k2, ok := d.Kanji('語')
if !ok {
t.Fatalf("Kanji('語') not found")
}
if k2.Strokes != 14 {
t.Errorf("Strokes = %d, want 14", k2.Strokes)
}
_, ok = d.Kanji('?')
if ok {
t.Errorf("expected Kanji('?') to return false")
}
}
func TestPitchAttachment(t *testing.T) {
d := buildTestDict(t, false)
// 1. 食べる -> downstep 2
entries := d.Lookup("食べる")
if len(entries) == 0 {
t.Fatalf("no entry for 食べる")
}
e := entries[0]
if len(e.Pitch) == 0 {
t.Fatalf("no pitch attached to 食べる")
}
if e.Pitch[0].Reading != "たべる" {
t.Errorf("pitch reading = %q, want 'たべる'", e.Pitch[0].Reading)
}
if !slices.Equal(e.Pitch[0].Downsteps, []int{2}) {
t.Errorf("pitch downsteps = %v, want [2]", e.Pitch[0].Downsteps)
}
// 2. かさかさ -> downsteps 1, 0
entries = d.Lookup("かさかさ")
if len(entries) == 0 {
t.Fatalf("no entry for かさかさ")
}
e = entries[0]
if len(e.Pitch) == 0 {
t.Fatalf("no pitch attached to かさかさ")
}
if !slices.Equal(e.Pitch[0].Downsteps, []int{1, 0}) {
t.Errorf("pitch downsteps = %v, want [1, 0]", e.Pitch[0].Downsteps)
}
// 3. ラーメン -> downstep 1
entries = d.Lookup("ラーメン")
if len(entries) == 0 {
t.Fatalf("no entry for ラーメン")
}
e = entries[0]
if len(e.Pitch) == 0 {
t.Fatalf("no pitch attached to ラーメン")
}
if !slices.Equal(e.Pitch[0].Downsteps, []int{1}) {
t.Errorf("pitch downsteps = %v, want [1]", e.Pitch[0].Downsteps)
}
}
func TestTagLabel(t *testing.T) {
d := buildTestDict(t, false)
if label := d.TagLabel("v1"); label != "Ichidan verb" {
t.Errorf("d.TagLabel('v1') = %q, want 'Ichidan verb'", label)
}
if label := d.TagLabel("vt"); label != "transitive verb" {
t.Errorf("d.TagLabel('vt') = %q, want 'transitive verb'", label)
}
if label := d.TagLabel("n"); label != "noun (common) (futsuumeishi)" {
t.Errorf("d.TagLabel('n') = %q, want 'noun (common) (futsuumeishi)'", label)
}
if label := d.TagLabel("unknown_tag_xyz"); label != "unknown_tag_xyz" {
t.Errorf("d.TagLabel('unknown_tag_xyz') = %q, want 'unknown_tag_xyz'", label)
}
}
func TestFurigana(t *testing.T) {
d := buildTestDict(t, false)
rubies, ok := d.Furigana("日本語", "にほんご")
if !ok {
t.Fatalf("Furigana('日本語', 'にほんご') not found")
}
want := []dict.Ruby{
{Text: "日", Ruby: "に"},
{Text: "本", Ruby: "ほん"},
{Text: "語", Ruby: "ご"},
}
if !slices.Equal(rubies, want) {
t.Errorf("Furigana('日本語', 'にほんご') = %+v, want %+v", rubies, want)
}
rubies, ok = d.Furigana("今日", "きょう")
if !ok {
t.Fatalf("Furigana('今日', 'きょう') not found")
}
wantKyo := []dict.Ruby{
{Text: "今日", Ruby: "きょう"},
}
if !slices.Equal(rubies, wantKyo) {
t.Errorf("Furigana('今日', 'きょう') = %+v, want %+v", rubies, wantKyo)
}
rubies, ok = d.Furigana("食べる", "たべる")
if !ok {
t.Fatalf("Furigana('食べる', 'たべる') not found")
}
wantTaberu := []dict.Ruby{
{Text: "食", Ruby: "た"},
{Text: "べる", Ruby: ""},
}
if !slices.Equal(rubies, wantTaberu) {
t.Errorf("Furigana('食べる', 'たべる') = %+v, want %+v", rubies, wantTaberu)
}
rubies, ok = d.Furigana("大人", "おとな")
if !ok {
t.Fatalf("Furigana('大人', 'おとな') not found")
}
wantOtona := []dict.Ruby{
{Text: "大人", Ruby: "おとな"},
}
if !slices.Equal(rubies, wantOtona) {
t.Errorf("Furigana('大人', 'おとな') = %+v, want %+v", rubies, wantOtona)
}
rubies, ok = d.Furigana("食べる", "タベル")
if !ok {
t.Fatalf("Furigana('食べる', 'タベル') not found")
}
if !slices.Equal(rubies, wantTaberu) {
t.Errorf("Furigana('食べる', 'タベル') = %+v, want %+v", rubies, wantTaberu)
}
_, ok = d.Furigana("存在しない", "そんざいしない")
if ok {
t.Errorf("expected false for non-existent furigana")
}
}
func TestComponents(t *testing.T) {
d := buildTestDict(t, false)
comps := d.Components('食')
if !slices.Equal(comps, []rune{'食'}) {
t.Errorf("Components('食') = %v, want ['食']", comps)
}
comps = d.Components('語')
want := []rune{'言', '口', '五'}
if !slices.Equal(comps, want) {
t.Errorf("Components('語') = %v, want %v", comps, want)
}
comps = d.Components('良')
if !slices.Equal(comps, []rune{'艮'}) {
t.Errorf("Components('良') = %v, want ['艮']", comps)
}
// Verify display component forms: 化->⺅, 艾->艹, 汁->氵, 込->辶, ｜->丨, ノ->丿
if comps = d.Components('休'); !slices.Equal(comps, []rune{'⺅', '木'}) {
t.Errorf("Components('休') = %v (%c), want [⺅, 木]", comps, comps)
}
if comps = d.Components('花'); !slices.Equal(comps, []rune{'⺅', '匕', '艹'}) {
t.Errorf("Components('花') = %v (%c), want [⺅, 匕, 艹]", comps, comps)
}
if comps = d.Components('働'); !slices.Equal(comps, []rune{'丨', '一', '⺅', '力', '日', '丿'}) {
t.Errorf("Components('働') = %v (%c), want [丨, 一, ⺅, 力, 日, 丿]", comps, comps)
}
if comps = d.Components('？'); comps != nil {
t.Errorf("Components('？') = %v, want nil", comps)
}
}
func TestKanjiWith(t *testing.T) {
d := buildTestDict(t, false)
// In testdata/radkfile.json, 艮 has ["良", "銀", "限"]
// In testdata/kanjidic.json:
// 銀: freq 395
// 限: freq 405
// 良: freq 501
// Order must be: 銀, 限, 良
res := d.KanjiWith('艮', 10)
want := []rune{'銀', '限', '良'}
if !slices.Equal(res, want) {
t.Errorf("KanjiWith('艮', 10) = %v (%c %c %c), want %v (%c %c %c)",
res, res[0], res[1], res[2], want, want[0], want[1], want[2])
}
// KanjiWith('良', 8) resolves 良 -> single component 艮 -> returns [銀, 限, 良]
res = d.KanjiWith('良', 8)
if !slices.Equal(res, want) {
t.Errorf("KanjiWith('良', 8) = %v, want %v", res, want)
}
// Both display form and placeholder form must work:
// ⺅ and 化
k1 := d.KanjiWith('⺅', 10)
k2 := d.KanjiWith('化', 10)
if len(k1) == 0 || !slices.Equal(k1, k2) {
t.Errorf("KanjiWith('⺅') != KanjiWith('化'): %v vs %v", k1, k2)
}
// 艹 and 艾
if k1, k2 := d.KanjiWith('艹', 10), d.KanjiWith('艾', 10); len(k1) == 0 || !slices.Equal(k1, k2) {
t.Errorf("KanjiWith('艹') != KanjiWith('艾'): %v vs %v", k1, k2)
}
// 氵 and 汁
if k1, k2 := d.KanjiWith('氵', 10), d.KanjiWith('汁', 10); len(k1) == 0 || !slices.Equal(k1, k2) {
t.Errorf("KanjiWith('氵') != KanjiWith('汁'): %v vs %v", k1, k2)
}
// 辶 and 込
if k1, k2 := d.KanjiWith('辶', 10), d.KanjiWith('込', 10); len(k1) == 0 || !slices.Equal(k1, k2) {
t.Errorf("KanjiWith('辶') != KanjiWith('込'): %v vs %v", k1, k2)
}
// 丨 and ｜
if k1, k2 := d.KanjiWith('丨', 10), d.KanjiWith('｜', 10); len(k1) == 0 || !slices.Equal(k1, k2) {
t.Errorf("KanjiWith('丨') != KanjiWith('｜'): %v vs %v", k1, k2)
}
// 丿 and ノ
if k1, k2 := d.KanjiWith('丿', 10), d.KanjiWith('ノ', 10); len(k1) == 0 || !slices.Equal(k1, k2) {
t.Errorf("KanjiWith('丿') != KanjiWith('ノ'): %v vs %v", k1, k2)
}
// Max limit
res = d.KanjiWith('艮', 2)
if !slices.Equal(res, []rune{'銀', '限'}) {
t.Errorf("KanjiWith('艮', 2) = %v, want ['銀', '限']", res)
}
// Non-positive max returns nil
if res = d.KanjiWith('艮', 0); res != nil {
t.Errorf("KanjiWith('艮', 0) = %v, want nil", res)
}
if res = d.KanjiWith('艮', -1); res != nil {
t.Errorf("KanjiWith('艮', -1) = %v, want nil", res)
}
}
func TestComponentName(t *testing.T) {
d := buildTestDict(t, false)
cases := []struct {
r rune
want string
}{
{'宀', "roof"},
{'亠', "lid"},
{'冖', "cover"},
{'儿', "legs"},
{'丨', "line"},
{'丿', "slash"},
{'匕', "spoon"},
{'艹', "grass"},
{'⺅', "person"},
{'忄', "heart"},
{'氵', "water"},
{'辶', "walk"},
{'食', "eat"},
{'⺡', "water"},
{'⺉', "knife"},
}
for _, tc := range cases {
got := d.ComponentName(tc.r)
if got != tc.want {
t.Errorf("ComponentName(%c / U+%04X) = %q, want %q", tc.r, tc.r, got, tc.want)
}
}
}
func TestKanjiComponentsAndNamesTable(t *testing.T) {
d := buildTestDict(t, false)
table := []struct {
kanji rune
comps []rune
names []string
}{
{'休', []rune{'⺅', '木'}, []string{"person", "tree"}},
{'花', []rune{'⺅', '匕', '艹'}, []string{"person", "spoon", "grass"}},
{'働', []rune{'丨', '一', '⺅', '力', '日', '丿'}, []string{"line", "one", "person", "power", "sun", "slash"}},
{'語', []rune{'言', '口', '五'}, []string{"words", "mouth", "five"}},
{'読', []rune{'言', '士', '儿', '冖'}, []string{"words", "scholar", "legs", "cover"}},
{'海', []rune{'氵', '母', '毋', '乞'}, []string{"water", "mother", "do not", "beg"}},
{'道', []rune{'辶', '自', '丷', '首'}, []string{"walk", "oneself", "horns", "head"}},
{'家', []rune{'宀', '豕'}, []string{"roof", "pig"}},
{'想', []rune{'心', '木', '目'}, []string{"heart", "tree", "eye"}},
{'校', []rune{'父', '木', '亠'}, []string{"father", "tree", "lid"}},
}
for _, tc := range table {
gotComps := d.Components(tc.kanji)
if !slices.Equal(gotComps, tc.comps) {
t.Errorf("Components(%c) = %v (%c), want %v (%c)", tc.kanji, gotComps, gotComps, tc.comps, tc.comps)
}
gotNames := make([]string, len(gotComps))
for i, c := range gotComps {
gotNames[i] = d.ComponentName(c)
}
if !slices.Equal(gotNames, tc.names) {
t.Errorf("ComponentNames for %c = %v, want %v", tc.kanji, gotNames, tc.names)
}
}
}
func TestWordsWith(t *testing.T) {
d := buildTestDict(t, false)
words := d.WordsWith('食', 10)
if len(words) < 2 {
t.Fatalf("WordsWith('食', 10) returned %d entries, want at least 2", len(words))
}
// First should be 食べる (common, priority nf02)
if words[0].Kanji[0].Text != "食べる" {
t.Errorf("words[0] = %q, want '食べる'", words[0].Kanji[0].Text)
}
// Second should be 食事
if words[1].Kanji[0].Text != "食事" {
t.Errorf("words[1] = %q, want '食事'", words[1].Kanji[0].Text)
}
// Verify that 食偽 (search-only sK form) was excluded
for _, w := range words {
for _, k := range w.Kanji {
if k.Text == "食偽" {
t.Errorf("WordsWith('食') included search-only word '食偽'")
}
}
}
// Max limit
wordsLimited := d.WordsWith('食', 1)
if len(wordsLimited) != 1 {
t.Errorf("WordsWith('食', 1) length = %d, want 1", len(wordsLimited))
}
// Non-positive max returns nil
if w := d.WordsWith('食', 0); w != nil {
t.Errorf("WordsWith('食', 0) = %v, want nil", w)
}
// Non-existent kanji
if w := d.WordsWith('？', 10); w != nil {
t.Errorf("WordsWith('？', 10) = %v, want nil", w)
}
}
func TestOpenRejectsOldVersion(t *testing.T) {
// A file with version 1
var buf [160]byte
copy(buf[0:8], dict.MagicString)
binary.LittleEndian.PutUint32(buf[8:12], 1) // version 1
tmpPath := filepath.Join(t.TempDir(), "olddict.bin")
if err := os.WriteFile(tmpPath, buf[:], 0644); err != nil {
t.Fatal(err)
}
_, err := dict.Open(tmpPath)
if err == nil {
t.Fatal("expected error opening old version file, got nil")
}
if !strings.Contains(err.Error(), "run chirami setup") {
t.Errorf("error %q does not contain 'run chirami setup'", err.Error())
}
}