Use PrevWordsInfo for get/add/remove n-gram(bigram) entry.

Bug: 14119293
Bug: 14425059

Change-Id: I12e9ba977c153b514c6591ab52940712fd0874e3

1 files changed, 86 insertions, 74 deletions

diff --git a/tests/src/com/android/inputmethod/latin/BinaryDictionaryTests.java b/tests/src/com/android/inputmethod/latin/BinaryDictionaryTests.java
index c87c2a970..2b82e544a 100644
--- a/tests/src/com/android/inputmethod/latin/BinaryDictionaryTests.java
+++ b/tests/src/com/android/inputmethod/latin/BinaryDictionaryTests.java
@@ -170,7 +170,7 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         addUnigramWord(binaryDictionary, validLongWord, probability);
         addUnigramWord(binaryDictionary, invalidLongWord, probability);
         // Too long short cut.
-        binaryDictionary.addUnigramWord("a", probability, invalidLongWord,
+        binaryDictionary.addUnigramEntry("a", probability, invalidLongWord,
                 10 /* shortcutProbability */, false /* isNotAWord */, false /* isBlacklisted */,
                 BinaryDictionary.NOT_A_VALID_TIMESTAMP);
         addUnigramWord(binaryDictionary, "abc", probability);
@@ -188,20 +188,35 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         dictFile.delete();
     }
 
-    private void addUnigramWord(final BinaryDictionary binaryDictionary, final String word,
+    private static void addUnigramWord(final BinaryDictionary binaryDictionary, final String word,
             final int probability) {
-        binaryDictionary.addUnigramWord(word, probability, "" /* shortcutTarget */,
+        binaryDictionary.addUnigramEntry(word, probability, "" /* shortcutTarget */,
                 BinaryDictionary.NOT_A_PROBABILITY /* shortcutProbability */,
                 false /* isNotAWord */, false /* isBlacklisted */,
                 BinaryDictionary.NOT_A_VALID_TIMESTAMP /* timestamp */);
     }
 
-    private void addBigramWords(final BinaryDictionary binaryDictionary, final String word0,
+    private static void addBigramWords(final BinaryDictionary binaryDictionary, final String word0,
             final String word1, final int probability) {
-        binaryDictionary.addBigramWords(word0, word1, probability,
+        binaryDictionary.addNgramEntry(new PrevWordsInfo(word0), word1, probability,
                 BinaryDictionary.NOT_A_VALID_TIMESTAMP /* timestamp */);
     }
 
+    private static boolean isValidBigram(final BinaryDictionary binaryDictionary,
+            final String word0, final String word1) {
+        return binaryDictionary.isValidNgram(new PrevWordsInfo(word0), word1);
+    }
+
+    private static void removeBigramEntry(final BinaryDictionary binaryDictionary,
+            final String word0, final String word1) {
+        binaryDictionary.removeNgramEntry(new PrevWordsInfo(word0), word1);
+    }
+
+    private static int getBigramProbability(final BinaryDictionary binaryDictionary,
+            final String word0,  final String word1) {
+        return binaryDictionary.getNgramProbability(new PrevWordsInfo(word0), word1);
+    }
+
     public void testAddUnigramWord() {
         for (final int formatVersion : DICT_FORMAT_VERSIONS) {
             testAddUnigramWord(formatVersion);
@@ -312,32 +327,32 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         addBigramWords(binaryDictionary, "abb", "aaa", bigramProbability);
         addBigramWords(binaryDictionary, "abb", "bcc", bigramProbability);
 
-        assertTrue(binaryDictionary.isValidBigram("aaa", "abb"));
-        assertTrue(binaryDictionary.isValidBigram("aaa", "bcc"));
-        assertTrue(binaryDictionary.isValidBigram("abb", "aaa"));
-        assertTrue(binaryDictionary.isValidBigram("abb", "bcc"));
+        assertTrue(isValidBigram(binaryDictionary, "aaa", "abb"));
+        assertTrue(isValidBigram(binaryDictionary, "aaa", "bcc"));
+        assertTrue(isValidBigram(binaryDictionary, "abb", "aaa"));
+        assertTrue(isValidBigram(binaryDictionary, "abb", "bcc"));
         if (canCheckBigramProbability(formatVersion)) {
-            assertEquals(bigramProbability, binaryDictionary.getBigramProbability("aaa", "abb"));
-            assertEquals(bigramProbability, binaryDictionary.getBigramProbability("aaa", "bcc"));
-            assertEquals(bigramProbability, binaryDictionary.getBigramProbability("abb", "aaa"));
-            assertEquals(bigramProbability, binaryDictionary.getBigramProbability("abb", "bcc"));
+            assertEquals(bigramProbability, getBigramProbability(binaryDictionary, "aaa", "abb"));
+            assertEquals(bigramProbability, getBigramProbability(binaryDictionary, "aaa", "bcc"));
+            assertEquals(bigramProbability, getBigramProbability(binaryDictionary, "abb", "aaa"));
+            assertEquals(bigramProbability, getBigramProbability(binaryDictionary, "abb", "bcc"));
         }
 
         addBigramWords(binaryDictionary, "aaa", "abb", updatedBigramProbability);
         if (canCheckBigramProbability(formatVersion)) {
             assertEquals(updatedBigramProbability,
-                    binaryDictionary.getBigramProbability("aaa", "abb"));
+                    getBigramProbability(binaryDictionary, "aaa", "abb"));
         }
 
-        assertFalse(binaryDictionary.isValidBigram("bcc", "aaa"));
-        assertFalse(binaryDictionary.isValidBigram("bcc", "bbc"));
-        assertFalse(binaryDictionary.isValidBigram("aaa", "aaa"));
+        assertFalse(isValidBigram(binaryDictionary, "bcc", "aaa"));
+        assertFalse(isValidBigram(binaryDictionary, "bcc", "bbc"));
+        assertFalse(isValidBigram(binaryDictionary, "aaa", "aaa"));
         assertEquals(Dictionary.NOT_A_PROBABILITY,
-                binaryDictionary.getBigramProbability("bcc", "aaa"));
+                getBigramProbability(binaryDictionary, "bcc", "aaa"));
         assertEquals(Dictionary.NOT_A_PROBABILITY,
-                binaryDictionary.getBigramProbability("bcc", "bbc"));
+                getBigramProbability(binaryDictionary, "bcc", "bbc"));
         assertEquals(Dictionary.NOT_A_PROBABILITY,
-                binaryDictionary.getBigramProbability("aaa", "aaa"));
+                getBigramProbability(binaryDictionary, "aaa", "aaa"));
 
         // Testing bigram link.
         addUnigramWord(binaryDictionary, "abcde", unigramProbability);
@@ -349,14 +364,14 @@ public class BinaryDictionaryTests extends AndroidTestCase {
 
         if (canCheckBigramProbability(formatVersion)) {
             assertEquals(bigramProbability,
-                    binaryDictionary.getBigramProbability("abcde", "fghij"));
+                    getBigramProbability(binaryDictionary, "abcde", "fghij"));
         }
         assertEquals(Dictionary.NOT_A_PROBABILITY,
-                binaryDictionary.getBigramProbability("abcde", "fgh"));
+                getBigramProbability(binaryDictionary, "abcde", "fgh"));
         addBigramWords(binaryDictionary, "abcde", "fghij", updatedBigramProbability);
         if (canCheckBigramProbability(formatVersion)) {
             assertEquals(updatedBigramProbability,
-                    binaryDictionary.getBigramProbability("abcde", "fghij"));
+                    getBigramProbability(binaryDictionary, "abcde", "fghij"));
         }
 
         dictFile.delete();
@@ -418,10 +433,10 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         for (final Pair<String, String> bigram : bigramWords) {
             final int bigramProbability = bigramProbabilities.get(bigram);
             assertEquals(bigramProbability != Dictionary.NOT_A_PROBABILITY,
-                    binaryDictionary.isValidBigram(bigram.first, bigram.second));
+                    isValidBigram(binaryDictionary, bigram.first, bigram.second));
             if (canCheckBigramProbability(formatVersion)) {
                 assertEquals(bigramProbability,
-                        binaryDictionary.getBigramProbability(bigram.first, bigram.second));
+                        getBigramProbability(binaryDictionary, bigram.first, bigram.second));
             }
         }
 
@@ -454,28 +469,28 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         addBigramWords(binaryDictionary, "abb", "aaa", bigramProbability);
         addBigramWords(binaryDictionary, "abb", "bcc", bigramProbability);
 
-        assertTrue(binaryDictionary.isValidBigram("aaa", "abb"));
-        assertTrue(binaryDictionary.isValidBigram("aaa", "bcc"));
-        assertTrue(binaryDictionary.isValidBigram("abb", "aaa"));
-        assertTrue(binaryDictionary.isValidBigram("abb", "bcc"));
+        assertTrue(isValidBigram(binaryDictionary, "aaa", "abb"));
+        assertTrue(isValidBigram(binaryDictionary, "aaa", "bcc"));
+        assertTrue(isValidBigram(binaryDictionary, "abb", "aaa"));
+        assertTrue(isValidBigram(binaryDictionary, "abb", "bcc"));
 
-        binaryDictionary.removeBigramWords("aaa", "abb");
-        assertFalse(binaryDictionary.isValidBigram("aaa", "abb"));
+        removeBigramEntry(binaryDictionary, "aaa", "abb");
+        assertFalse(isValidBigram(binaryDictionary, "aaa", "abb"));
         addBigramWords(binaryDictionary, "aaa", "abb", bigramProbability);
-        assertTrue(binaryDictionary.isValidBigram("aaa", "abb"));
+        assertTrue(isValidBigram(binaryDictionary, "aaa", "abb"));
 
 
-        binaryDictionary.removeBigramWords("aaa", "bcc");
-        assertFalse(binaryDictionary.isValidBigram("aaa", "bcc"));
-        binaryDictionary.removeBigramWords("abb", "aaa");
-        assertFalse(binaryDictionary.isValidBigram("abb", "aaa"));
-        binaryDictionary.removeBigramWords("abb", "bcc");
-        assertFalse(binaryDictionary.isValidBigram("abb", "bcc"));
+        removeBigramEntry(binaryDictionary, "aaa", "bcc");
+        assertFalse(isValidBigram(binaryDictionary, "aaa", "bcc"));
+        removeBigramEntry(binaryDictionary, "abb", "aaa");
+        assertFalse(isValidBigram(binaryDictionary, "abb", "aaa"));
+        removeBigramEntry(binaryDictionary, "abb", "bcc");
+        assertFalse(isValidBigram(binaryDictionary, "abb", "bcc"));
 
-        binaryDictionary.removeBigramWords("aaa", "abb");
+        removeBigramEntry(binaryDictionary, "aaa", "abb");
         // Test remove non-existing bigram operation.
-        binaryDictionary.removeBigramWords("aaa", "abb");
-        binaryDictionary.removeBigramWords("bcc", "aaa");
+        removeBigramEntry(binaryDictionary, "aaa", "abb");
+        removeBigramEntry(binaryDictionary, "bcc", "aaa");
 
         dictFile.delete();
     }
@@ -570,14 +585,14 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         assertEquals(unigramProbability, binaryDictionary.getFrequency("abb"));
         assertEquals(unigramProbability, binaryDictionary.getFrequency("bcc"));
         if (canCheckBigramProbability(formatVersion)) {
-            assertEquals(bigramProbability, binaryDictionary.getBigramProbability("aaa", "abb"));
-            assertEquals(bigramProbability, binaryDictionary.getBigramProbability("aaa", "bcc"));
-            assertEquals(bigramProbability, binaryDictionary.getBigramProbability("abb", "aaa"));
-            assertEquals(bigramProbability, binaryDictionary.getBigramProbability("abb", "bcc"));
-        }
-        assertFalse(binaryDictionary.isValidBigram("bcc", "aaa"));
-        assertFalse(binaryDictionary.isValidBigram("bcc", "bbc"));
-        assertFalse(binaryDictionary.isValidBigram("aaa", "aaa"));
+            assertEquals(bigramProbability, getBigramProbability(binaryDictionary, "aaa", "abb"));
+            assertEquals(bigramProbability, getBigramProbability(binaryDictionary, "aaa", "bcc"));
+            assertEquals(bigramProbability, getBigramProbability(binaryDictionary, "abb", "aaa"));
+            assertEquals(bigramProbability, getBigramProbability(binaryDictionary, "abb", "bcc"));
+        }
+        assertFalse(isValidBigram(binaryDictionary, "bcc", "aaa"));
+        assertFalse(isValidBigram(binaryDictionary, "bcc", "bbc"));
+        assertFalse(isValidBigram(binaryDictionary, "aaa", "aaa"));
         binaryDictionary.flushWithGC();
         binaryDictionary.close();
 
@@ -649,10 +664,10 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         for (final Pair<String, String> bigram : bigramWords) {
             final int bigramProbability = bigramProbabilities.get(bigram);
             assertEquals(bigramProbability != Dictionary.NOT_A_PROBABILITY,
-                    binaryDictionary.isValidBigram(bigram.first, bigram.second));
+                    isValidBigram(binaryDictionary, bigram.first, bigram.second));
             if (canCheckBigramProbability(formatVersion)) {
                 assertEquals(bigramProbability,
-                        binaryDictionary.getBigramProbability(bigram.first, bigram.second));
+                        getBigramProbability(binaryDictionary, bigram.first, bigram.second));
             }
         }
 
@@ -742,7 +757,7 @@ public class BinaryDictionaryTests extends AndroidTestCase {
                     final Pair<String, String> bigram = bigramWords.get(bigramIndex);
                     bigramWords.remove(bigramIndex);
                     bigramProbabilities.remove(bigram);
-                    binaryDictionary.removeBigramWords(bigram.first, bigram.second);
+                    removeBigramEntry(binaryDictionary, bigram.first, bigram.second);
                 }
             }
 
@@ -765,10 +780,10 @@ public class BinaryDictionaryTests extends AndroidTestCase {
 
                 if (canCheckBigramProbability(formatVersion)) {
                     assertEquals(probability,
-                            binaryDictionary.getBigramProbability(bigram.first, bigram.second));
+                            getBigramProbability(binaryDictionary, bigram.first, bigram.second));
                 }
                 assertEquals(probability != Dictionary.NOT_A_PROBABILITY,
-                        binaryDictionary.isValidBigram(bigram.first, bigram.second));
+                        isValidBigram(binaryDictionary, bigram.first, bigram.second));
             }
             binaryDictionary.flushWithGC();
             binaryDictionary.close();
@@ -946,10 +961,10 @@ public class BinaryDictionaryTests extends AndroidTestCase {
             final String word1 = entry.getKey().second;
             final int bigramProbability = entry.getValue();
             assertEquals(bigramProbability != Dictionary.NOT_A_PROBABILITY,
-                    binaryDictionary.isValidBigram(word0, word1));
+                    isValidBigram(binaryDictionary, word0, word1));
             if (canCheckBigramProbability(formatVersion)) {
                 assertEquals(bigramProbability,
-                        binaryDictionary.getBigramProbability(word0, word1));
+                        getBigramProbability(binaryDictionary, word0, word1));
             }
         }
     }
@@ -993,7 +1008,7 @@ public class BinaryDictionaryTests extends AndroidTestCase {
             final boolean isNotAWord = random.nextBoolean();
             final boolean isBlacklisted = random.nextBoolean();
             // TODO: Add tests for historical info.
-            binaryDictionary.addUnigramWord(word, unigramProbability,
+            binaryDictionary.addUnigramEntry(word, unigramProbability,
                     null /* shortcutTarget */, BinaryDictionary.NOT_A_PROBABILITY,
                     isNotAWord, isBlacklisted, BinaryDictionary.NOT_A_VALID_TIMESTAMP);
             if (binaryDictionary.needsToRunGC(false /* mindsBlockByGC */)) {
@@ -1023,8 +1038,7 @@ public class BinaryDictionaryTests extends AndroidTestCase {
             final int unigramProbability = wordProbabilities.get(word1);
             final int bigramProbability =
                     unigramProbability + random.nextInt(0xFF - unigramProbability);
-            binaryDictionary.addBigramWords(word0, word1, bigramProbability,
-                    BinaryDictionary.NOT_A_VALID_TIMESTAMP);
+            addBigramWords(binaryDictionary, word0, word1, bigramProbability);
             if (binaryDictionary.needsToRunGC(false /* mindsBlockByGC */)) {
                 binaryDictionary.flushWithGC();
             }
@@ -1112,8 +1126,7 @@ public class BinaryDictionaryTests extends AndroidTestCase {
             final int unigramProbability = wordProbabilitiesToCheckLater.get(word1);
             final int bigramProbability =
                     unigramProbability + random.nextInt(0xFF - unigramProbability);
-            binaryDictionary.addBigramWords(word0, word1, bigramProbability,
-                    BinaryDictionary.NOT_A_VALID_TIMESTAMP);
+            addBigramWords(binaryDictionary, word0, word1, bigramProbability);
             if (binaryDictionary.needsToRunGC(false /* mindsBlockByGC */)) {
                 binaryDictionary.flushWithGC();
             }
@@ -1174,7 +1187,7 @@ public class BinaryDictionaryTests extends AndroidTestCase {
 
         final int unigramProbability = 100;
         final int shortcutProbability = 10;
-        binaryDictionary.addUnigramWord("aaa", unigramProbability, "zzz",
+        binaryDictionary.addUnigramEntry("aaa", unigramProbability, "zzz",
                 shortcutProbability, false /* isNotAWord */, false /* isBlacklisted */,
                 0 /* timestamp */);
         WordProperty wordProperty = binaryDictionary.getWordProperty("aaa");
@@ -1182,7 +1195,7 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         assertEquals("zzz", wordProperty.mShortcutTargets.get(0).mWord);
         assertEquals(shortcutProbability, wordProperty.mShortcutTargets.get(0).getProbability());
         final int updatedShortcutProbability = 2;
-        binaryDictionary.addUnigramWord("aaa", unigramProbability, "zzz",
+        binaryDictionary.addUnigramEntry("aaa", unigramProbability, "zzz",
                 updatedShortcutProbability, false /* isNotAWord */, false /* isBlacklisted */,
                 0 /* timestamp */);
         wordProperty = binaryDictionary.getWordProperty("aaa");
@@ -1190,7 +1203,7 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         assertEquals("zzz", wordProperty.mShortcutTargets.get(0).mWord);
         assertEquals(updatedShortcutProbability,
                 wordProperty.mShortcutTargets.get(0).getProbability());
-        binaryDictionary.addUnigramWord("aaa", unigramProbability, "yyy",
+        binaryDictionary.addUnigramEntry("aaa", unigramProbability, "yyy",
                 shortcutProbability, false /* isNotAWord */, false /* isBlacklisted */,
                 0 /* timestamp */);
         final HashMap<String, Integer> shortcutTargets = new HashMap<String, Integer>();
@@ -1261,7 +1274,7 @@ public class BinaryDictionaryTests extends AndroidTestCase {
             final int shortcutProbability = random.nextInt(0xF);
             final String word = words.get(random.nextInt(words.size()));
             final int unigramProbability = unigramProbabilities.get(word);
-            binaryDictionary.addUnigramWord(word, unigramProbability, shortcutTarget,
+            binaryDictionary.addUnigramEntry(word, unigramProbability, shortcutTarget,
                     shortcutProbability, false /* isNotAWord */, false /* isBlacklisted */,
                     0 /* timestamp */);
             if (shortcutTargets.containsKey(word)) {
@@ -1317,14 +1330,14 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         final int bigramProbability = 150;
         addBigramWords(binaryDictionary, "aaa", "bbb", bigramProbability);
         final int shortcutProbability = 10;
-        binaryDictionary.addUnigramWord("ccc", unigramProbability, "xxx", shortcutProbability,
+        binaryDictionary.addUnigramEntry("ccc", unigramProbability, "xxx", shortcutProbability,
                 false /* isNotAWord */, false /* isBlacklisted */, 0 /* timestamp */);
-        binaryDictionary.addUnigramWord("ddd", unigramProbability, null /* shortcutTarget */,
+        binaryDictionary.addUnigramEntry("ddd", unigramProbability, null /* shortcutTarget */,
                 Dictionary.NOT_A_PROBABILITY, true /* isNotAWord */,
                 true /* isBlacklisted */, 0 /* timestamp */);
         assertEquals(unigramProbability, binaryDictionary.getFrequency("aaa"));
         assertEquals(unigramProbability, binaryDictionary.getFrequency("bbb"));
-        assertTrue(binaryDictionary.isValidBigram("aaa", "bbb"));
+        assertTrue(isValidBigram(binaryDictionary, "aaa", "bbb"));
         assertEquals(fromFormatVersion, binaryDictionary.getFormatVersion());
         assertTrue(binaryDictionary.migrateTo(toFormatVersion));
         assertTrue(binaryDictionary.isValidDictionary());
@@ -1332,9 +1345,9 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         assertEquals(unigramProbability, binaryDictionary.getFrequency("aaa"));
         assertEquals(unigramProbability, binaryDictionary.getFrequency("bbb"));
         if (canCheckBigramProbability(toFormatVersion)) {
-            assertEquals(bigramProbability, binaryDictionary.getBigramProbability("aaa", "bbb"));
+            assertEquals(bigramProbability, getBigramProbability(binaryDictionary, "aaa", "bbb"));
         }
-        assertTrue(binaryDictionary.isValidBigram("aaa", "bbb"));
+        assertTrue(isValidBigram(binaryDictionary, "aaa", "bbb"));
         WordProperty wordProperty = binaryDictionary.getWordProperty("ccc");
         assertEquals(1, wordProperty.mShortcutTargets.size());
         assertEquals("xxx", wordProperty.mShortcutTargets.get(0).mWord);
@@ -1395,8 +1408,7 @@ public class BinaryDictionaryTests extends AndroidTestCase {
             final int unigramProbability = unigramProbabilities.get(word1);
             final int bigramProbability =
                     random.nextInt(0xFF - unigramProbability) + unigramProbability;
-            binaryDictionary.addBigramWords(word0, word1, bigramProbability,
-                    BinaryDictionary.NOT_A_VALID_TIMESTAMP);
+            addBigramWords(binaryDictionary, word0, word1, bigramProbability);
             if (binaryDictionary.needsToRunGC(true /* mindsBlockByGC */)) {
                 binaryDictionary.flushWithGC();
             }
@@ -1415,9 +1427,9 @@ public class BinaryDictionaryTests extends AndroidTestCase {
         for (final Pair<String, String> bigram : bigrams) {
             if (canCheckBigramProbability(toFormatVersion)) {
                 assertEquals((int)bigramProbabilities.get(bigram),
-                        binaryDictionary.getBigramProbability(bigram.first, bigram.second));
+                        getBigramProbability(binaryDictionary, bigram.first, bigram.second));
             }
-            assertTrue(binaryDictionary.isValidBigram(bigram.first, bigram.second));
+            assertTrue(isValidBigram(binaryDictionary, bigram.first, bigram.second));
         }
         assertEquals(bigramProbabilities.size(), Integer.parseInt(
                 binaryDictionary.getPropertyForTest(BinaryDictionary.BIGRAM_COUNT_QUERY)));