1 package com.hughes.android.dictionary;
\r
4 import java.io.IOException;
\r
5 import java.io.RandomAccessFile;
\r
6 import java.util.ArrayList;
\r
7 import java.util.Arrays;
\r
8 import java.util.Collections;
\r
9 import java.util.LinkedHashSet;
\r
10 import java.util.List;
\r
11 import java.util.Set;
\r
12 import java.util.concurrent.atomic.AtomicBoolean;
\r
14 import junit.framework.TestCase;
\r
16 import com.hughes.android.dictionary.Dictionary.IndexEntry;
\r
17 import com.hughes.android.dictionary.Dictionary.LanguageData;
\r
18 import com.hughes.android.dictionary.Dictionary.Row;
\r
20 public class DictionaryTest extends TestCase {
\r
22 public void testDictionary() throws IOException {
\r
23 final File file = File.createTempFile("asdf", "asdf");
\r
24 file.deleteOnExit();
\r
26 // final Dictionary goldenDict;
\r
27 final List<SimpleEntry> entries = Arrays.asList(
\r
28 SimpleEntry.parseFromLine("der Hund :: the dog", false),
\r
29 SimpleEntry.parseFromLine("Die grosse Katze :: The big cat", false),
\r
30 SimpleEntry.parseFromLine("die Katze :: the cat", false),
\r
31 SimpleEntry.parseFromLine("gross :: big", false),
\r
32 SimpleEntry.parseFromLine("Dieb :: thief", false),
\r
33 SimpleEntry.parseFromLine("rennen :: run", false));
\r
36 final Dictionary dict = new Dictionary("test", Language.de, Language.en);
\r
37 dict.entries.addAll(entries);
\r
38 DictionaryBuilder.createIndex(dict, SimpleEntry.LANG1);
\r
39 DictionaryBuilder.createIndex(dict, SimpleEntry.LANG2);
\r
40 final RandomAccessFile raf = new RandomAccessFile(file, "rw");
\r
44 // goldenDict = dict;
\r
47 final RandomAccessFile raf = new RandomAccessFile(file, "r");
\r
48 final Dictionary dict = new Dictionary(raf);
\r
50 assertEquals(entries, dict.entries);
\r
52 assertEquals("der", dict.languageDatas[0].sortedIndex.get(0).word);
\r
53 assertEquals("die", dict.languageDatas[0].sortedIndex.get(1).word);
\r
55 assertEquals(0, dict.languageDatas[0].getPrevTokenRow(0));
\r
56 assertEquals(0, dict.languageDatas[0].getPrevTokenRow(2));
\r
57 assertEquals(0, dict.languageDatas[0].getPrevTokenRow(1));
\r
58 assertEquals(4, dict.languageDatas[0].getPrevTokenRow(6));
\r
60 assertEquals(2, dict.languageDatas[0].getNextTokenRow(0));
\r
61 assertEquals(2, dict.languageDatas[0].getNextTokenRow(1));
\r
62 assertEquals(4, dict.languageDatas[0].getNextTokenRow(2));
\r
63 assertEquals(8, dict.languageDatas[0].getNextTokenRow(6));
\r
64 assertEquals(dict.languageDatas[0].rows.size() - 1, dict.languageDatas[0].getNextTokenRow(dict.languageDatas[0].rows.size() - 2));
\r
65 assertEquals(dict.languageDatas[0].rows.size() - 1, dict.languageDatas[0].getNextTokenRow(dict.languageDatas[0].rows.size() - 1));
\r
67 for (final IndexEntry indexEntry : dict.languageDatas[0].sortedIndex) {
\r
68 System.out.println(indexEntry);
\r
72 for (final Row row : dict.languageDatas[0].rows) {
\r
73 if (row.index >= 0) {
\r
74 System.out.println(" " + rowCount + ":" + dict.entries.get(row.index));
\r
76 System.out.println(rowCount + ":" + dict.languageDatas[0].sortedIndex.get(-row.index - 1));
\r
81 for (int l = 0; l <= 1; l++) {
\r
82 final LanguageData languageData = dict.languageDatas[l];
\r
83 for (int i = 0; i < languageData.sortedIndex.size(); i++) {
\r
84 final IndexEntry indexEntry = languageData.sortedIndex.get(i);
\r
85 if (indexEntry.word.toLowerCase().equals("dieb"))
\r
86 System.out.println();
\r
87 final IndexEntry lookedUpEntry = languageData.sortedIndex.get(languageData.lookup(indexEntry.word, new AtomicBoolean(false)));
\r
88 if (!indexEntry.word.toLowerCase().equals(lookedUpEntry.word.toLowerCase()))
\r
89 System.out.println();
\r
90 assertEquals(indexEntry.word.toLowerCase(), lookedUpEntry.word.toLowerCase());
\r
94 assertEquals("die", dict.languageDatas[0].sortedIndex.get(dict.languageDatas[0].lookup("Die", new AtomicBoolean())).word);
\r
95 assertEquals("die", dict.languageDatas[0].sortedIndex.get(dict.languageDatas[0].lookup("die", new AtomicBoolean())).word);
\r
99 public void testTextNorm() throws IOException {
\r
100 System.out.println("\n\ntestTextNorm");
\r
101 final List<SimpleEntry> entries = Arrays.asList(
\r
102 SimpleEntry.parseFromLine("Hund {m} :: dog", true),
\r
103 SimpleEntry.parseFromLine("'CHRISTOS' :: doh", true),
\r
104 SimpleEntry.parseFromLine("\"Pick-up\"-Presse {f} :: baler", true),
\r
105 SimpleEntry.parseFromLine("(Ach was), echt? [auch ironisch] :: No shit! [also ironic]", true),
\r
106 SimpleEntry.parseFromLine("(akuter) Myokardinfarkt {m} <AMI / MI> :: (acute) myocardial infarction <AMI / MI>", true),
\r
107 SimpleEntry.parseFromLine("(reine) Vermutung {f} :: guesswork", true),
\r
108 SimpleEntry.parseFromLine("(mit) 6:1 vorne liegen :: to be 6-1 up [football]", true),
\r
109 SimpleEntry.parseFromLine("(auf) den Knopf drücken [auch fig.: auslösen] :: to push the button [also fig.: initiate]", false),
\r
110 SimpleEntry.parseFromLine("Adjektiv {n} /Adj./; Eigenschaftswort {n} [gramm.] | Adjektive {pl}; Eigenschaftswoerter {pl} :: adjective /adj./ | adjectives", true),
\r
111 SimpleEntry.parseFromLine("Älteste {m,f}; Ältester :: oldest; eldest", true),
\r
112 SimpleEntry.parseFromLine("\"...\", schloss er an. :: '...,' he added.", true),
\r
113 SimpleEntry.parseFromLine("besonderer | besondere | besonderes :: extra", false),
\r
114 SimpleEntry.parseFromLine("| zu Pferde; zu Pferd | reiten :: horseback | on horseback | go on horseback", true),
\r
115 SimpleEntry.parseFromLine("Hauptaugenmerk {m} | sein Hauptaugenmerk richten auf :: | to focus (one's) attention on", true),
\r
116 SimpleEntry.parseFromLine("σ-Algebra {f} :: σ-field", true)
\r
119 assertFalse(entries.contains(null));
\r
121 // Hyphenated words get put both multiple listings.
\r
123 final Dictionary dict = new Dictionary("test", Language.de, Language.en);
\r
124 dict.entries.addAll(entries);
\r
125 DictionaryBuilder.createIndex(dict, SimpleEntry.LANG1);
\r
126 DictionaryBuilder.createIndex(dict, SimpleEntry.LANG2);
\r
128 for (int lang = 0; lang <= 1; lang++) {
\r
129 final LanguageData languageData = dict.languageDatas[lang];
\r
130 System.out.println("\n" + languageData.language);
\r
131 final Set<String> words = new LinkedHashSet<String>();
\r
132 for (int i = 0; i < languageData.sortedIndex.size(); i++) {
\r
133 final IndexEntry indexEntry = languageData.sortedIndex.get(i);
\r
134 System.out.println(indexEntry);
\r
135 words.add(indexEntry.word);
\r
138 assertTrue(words.contains("CHRISTOS"));
\r
139 assertTrue(words.contains("akuter"));
\r
140 assertTrue(words.contains("σ-Algebra"));
\r
142 assertFalse(words.contains("-Algebra"));
\r
144 assertTrue(words.contains("σ-field"));
\r
145 assertTrue(words.contains("6-1"));
\r
151 public void testGermanSort() {
\r
152 assertEquals("aüÄ", Language.de.textNorm("aueAe"));
\r
153 final List<String> words = Arrays.asList(
\r
177 assertEquals(0, Language.de.sortComparator.compare("hülle", "huelle"));
\r
178 assertEquals(0, Language.de.sortComparator.compare("huelle", "hülle"));
\r
180 assertEquals(-1, Language.de.sortComparator.compare("hülle", "Hülle"));
\r
181 assertEquals(0, Language.de.findComparator.compare("hülle", "Hülle"));
\r
182 assertEquals(-1, Language.de.findComparator.compare("hulle", "Hülle"));
\r
185 for (final String s : words) {
\r
186 System.out.println(s + "\t" + Language.de.textNorm(s));
\r
188 final List<String> sorted = new ArrayList<String>(words);
\r
189 // Collections.shuffle(shuffled, new Random(0));
\r
190 Collections.sort(sorted, Language.de.sortComparator);
\r
191 System.out.println(sorted.toString());
\r
192 for (int i = 0; i < words.size(); ++i) {
\r
193 System.out.println(words.get(i) + "\t" + sorted.get(i));
\r
194 assertEquals(words.get(i), sorted.get(i));
\r
198 public void testEnglishSort() {
\r
200 final List<String> words = Arrays.asList(
\r
206 final List<String> sorted = new ArrayList<String>(words);
\r
207 Collections.sort(sorted, Language.en.sortComparator);
\r
208 for (int i = 0; i < words.size(); ++i) {
\r
210 assertTrue(Language.en.sortComparator.compare(words.get(i-1), words.get(i)) < 0);
\r
212 System.out.println(words.get(i) + "\t" + sorted.get(i));
\r
213 assertEquals(words.get(i), sorted.get(i));
\r
216 assertTrue(Language.en.sortCollator.compare("pre-print", "preppy") < 0);
\r
220 public void testLanguage() {
\r
221 System.out.println("languages=" + Language.symbolToLangauge.values());
\r
222 assertEquals(Language.de, Language.lookup("de"));
\r
223 assertEquals(Language.en, Language.lookup("en"));
\r
224 assertEquals("es", Language.lookup("es").symbol);
\r