src/com/hughes/android/dictionary/DictionaryTest.java

   1 package com.hughes.android.dictionary;\r
   2 \r
   3 import java.io.File;\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
  13 \r
  14 import junit.framework.TestCase;\r
  15 \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
  19 \r
  20 public class DictionaryTest extends TestCase {\r
  21 \r
  22   public void testDictionary() throws IOException {\r
  23     final File file = File.createTempFile("asdf", "asdf");\r
  24     file.deleteOnExit();\r
  25 \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
  34 \r
  35     {\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
  41       dict.write(raf);\r
  42       raf.close();\r
  43       \r
  44 //      goldenDict = dict;\r
  45     }\r
  46 \r
  47     final RandomAccessFile raf = new RandomAccessFile(file, "r");\r
  48     final Dictionary dict = new Dictionary(raf);\r
  49     \r
  50     assertEquals(entries, dict.entries);\r
  51     \r
  52     assertEquals("der", dict.languageDatas[0].sortedIndex.get(0).word);\r
  53     assertEquals("die", dict.languageDatas[0].sortedIndex.get(1).word);\r
  54     \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
  59 \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
  66 \r
  67     for (final IndexEntry indexEntry : dict.languageDatas[0].sortedIndex) {\r
  68       System.out.println(indexEntry);\r
  69     }\r
  70 \r
  71     int rowCount = 0;\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
  75       } else {\r
  76         System.out.println(rowCount + ":" + dict.languageDatas[0].sortedIndex.get(-row.index - 1));\r
  77       }\r
  78       ++rowCount;\r
  79     }\r
  80 \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
  91       }\r
  92     }\r
  93     \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
  96 \r
  97   }\r
  98   \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("&#963;-Algebra {f} :: &#963;-field", true)\r
 117         );\r
 118 \r
 119     assertFalse(entries.contains(null));\r
 120     \r
 121     // Hyphenated words get put both multiple listings.\r
 122 \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
 127     \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
 136       }\r
 137       if (lang == 0) {\r
 138         assertTrue(words.contains("CHRISTOS"));\r
 139         assertTrue(words.contains("akuter"));\r
 140         assertTrue(words.contains("σ-Algebra"));\r
 141 \r
 142         assertFalse(words.contains("-Algebra"));\r
 143       } else {\r
 144         assertTrue(words.contains("σ-field"));\r
 145         assertTrue(words.contains("6-1"));\r
 146       }\r
 147     }\r
 148 \r
 149   }\r
 150   \r
 151   public void testGermanSort() {\r
 152     assertEquals("aüÄ", Language.de.textNorm("aueAe"));\r
 153     final List<String> words = Arrays.asList(\r
 154         "er-ben",\r
 155         "erben",\r
 156         "Erben",\r
 157         "Erbse",\r
 158         "Erbsen",\r
 159         "essen",\r
 160         "Essen",\r
 161         "Grosformat",\r
 162         "Grosformats",\r
 163         "Grossformat",\r
 164         "Großformat",\r
 165         "Grossformats",\r
 166         "Großformats",\r
 167         "Großpoo",\r
 168         "Großpoos",\r
 169         "hulle",\r
 170         "Hulle",\r
 171         "hülle",\r
 172         "huelle",\r
 173         "Hülle",\r
 174         "Huelle",\r
 175         "Hum"\r
 176         );\r
 177     assertEquals(0, Language.de.sortComparator.compare("hülle", "huelle"));\r
 178     assertEquals(0, Language.de.sortComparator.compare("huelle", "hülle"));\r
 179     \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
 183 \r
 184     \r
 185     for (final String s : words) {\r
 186       System.out.println(s + "\t" + Language.de.textNorm(s));\r
 187     }\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
 195     }\r
 196   }\r
 197 \r
 198   public void testEnglishSort() {\r
 199 \r
 200     final List<String> words = Arrays.asList(\r
 201         "pre-print", \r
 202         "preppie", \r
 203         "preppy",\r
 204         "preprocess");\r
 205     \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
 209       if (i > 0) {\r
 210         assertTrue(Language.en.sortComparator.compare(words.get(i-1), words.get(i)) < 0);\r
 211       }\r
 212       System.out.println(words.get(i) + "\t" + sorted.get(i));\r
 213       assertEquals(words.get(i), sorted.get(i));\r
 214     }\r
 215     \r
 216     assertTrue(Language.en.sortCollator.compare("pre-print", "preppy") < 0);\r
 217 \r
 218   }\r
 219   \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
 225   }\r
 226 \r
 227 }\r