253 lines
9.7 KiB
Java
253 lines
9.7 KiB
Java
/*
|
|
* Copyright (C) 2012 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.inputmethod.latin;
|
|
|
|
import android.content.Context;
|
|
import android.test.AndroidTestCase;
|
|
import android.test.suitebuilder.annotation.LargeTest;
|
|
import android.util.Log;
|
|
|
|
import com.android.inputmethod.latin.UserHistoryDictIOUtils.BigramDictionaryInterface;
|
|
import com.android.inputmethod.latin.UserHistoryDictIOUtils.OnAddWordListener;
|
|
import com.android.inputmethod.latin.makedict.FormatSpec;
|
|
import com.android.inputmethod.latin.makedict.FusionDictionary;
|
|
import com.android.inputmethod.latin.makedict.FusionDictionary.CharGroup;
|
|
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileNotFoundException;
|
|
import java.io.FileOutputStream;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
|
|
/**
|
|
* Unit tests for UserHistoryDictIOUtils
|
|
*/
|
|
@LargeTest
|
|
public class UserHistoryDictIOUtilsTests extends AndroidTestCase
|
|
implements BigramDictionaryInterface {
|
|
|
|
private static final String TAG = UserHistoryDictIOUtilsTests.class.getSimpleName();
|
|
private static final int UNIGRAM_FREQUENCY = 50;
|
|
private static final int BIGRAM_FREQUENCY = 100;
|
|
private static final ArrayList<String> NOT_HAVE_BIGRAM = new ArrayList<String>();
|
|
private static final FormatSpec.FormatOptions FORMAT_OPTIONS = new FormatSpec.FormatOptions(2);
|
|
|
|
/**
|
|
* Return same frequency for all words and bigrams
|
|
*/
|
|
@Override
|
|
public int getFrequency(String word1, String word2) {
|
|
if (word1 == null) return UNIGRAM_FREQUENCY;
|
|
return BIGRAM_FREQUENCY;
|
|
}
|
|
|
|
// Utilities for Testing
|
|
|
|
private void addWord(final String word,
|
|
final HashMap<String, ArrayList<String> > addedWords) {
|
|
if (!addedWords.containsKey(word)) {
|
|
addedWords.put(word, new ArrayList<String>());
|
|
}
|
|
}
|
|
|
|
private void addBigram(final String word1, final String word2,
|
|
final HashMap<String, ArrayList<String> > addedWords) {
|
|
addWord(word1, addedWords);
|
|
addWord(word2, addedWords);
|
|
addedWords.get(word1).add(word2);
|
|
}
|
|
|
|
private void addBigramToBigramList(final String word1, final String word2,
|
|
final HashMap<String, ArrayList<String> > addedWords,
|
|
final UserHistoryDictionaryBigramList bigramList) {
|
|
bigramList.addBigram(null, word1);
|
|
bigramList.addBigram(word1, word2);
|
|
|
|
addBigram(word1, word2, addedWords);
|
|
}
|
|
|
|
private void checkWordInFusionDict(final FusionDictionary dict, final String word,
|
|
final ArrayList<String> expectedBigrams) {
|
|
final CharGroup group = FusionDictionary.findWordInTree(dict.mRoot, word);
|
|
assertNotNull(group);
|
|
assertTrue(group.isTerminal());
|
|
|
|
for (final String bigram : expectedBigrams) {
|
|
assertNotNull(group.getBigram(bigram));
|
|
}
|
|
}
|
|
|
|
private void checkWordsInFusionDict(final FusionDictionary dict,
|
|
final HashMap<String, ArrayList<String> > bigrams) {
|
|
for (final String word : bigrams.keySet()) {
|
|
if (bigrams.containsKey(word)) {
|
|
checkWordInFusionDict(dict, word, bigrams.get(word));
|
|
} else {
|
|
checkWordInFusionDict(dict, word, NOT_HAVE_BIGRAM);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void checkWordInBigramList(
|
|
final UserHistoryDictionaryBigramList bigramList, final String word,
|
|
final ArrayList<String> expectedBigrams) {
|
|
// check unigram
|
|
final HashMap<String,Byte> unigramMap = bigramList.getBigrams(null);
|
|
assertTrue(unigramMap.containsKey(word));
|
|
|
|
// check bigrams
|
|
final ArrayList<String> actualBigrams = new ArrayList<String>(
|
|
bigramList.getBigrams(word).keySet());
|
|
|
|
Collections.sort(expectedBigrams);
|
|
Collections.sort(actualBigrams);
|
|
assertEquals(expectedBigrams, actualBigrams);
|
|
}
|
|
|
|
private void checkWordsInBigramList(final UserHistoryDictionaryBigramList bigramList,
|
|
final HashMap<String, ArrayList<String> > addedWords) {
|
|
for (final String word : addedWords.keySet()) {
|
|
if (addedWords.containsKey(word)) {
|
|
checkWordInBigramList(bigramList, word, addedWords.get(word));
|
|
} else {
|
|
checkWordInBigramList(bigramList, word, NOT_HAVE_BIGRAM);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void writeDictToFile(final File file,
|
|
final UserHistoryDictionaryBigramList bigramList) {
|
|
try {
|
|
final FileOutputStream out = new FileOutputStream(file);
|
|
UserHistoryDictIOUtils.writeDictionaryBinary(out, this, bigramList, FORMAT_OPTIONS);
|
|
out.flush();
|
|
out.close();
|
|
} catch (IOException e) {
|
|
Log.e(TAG, "IO exception while writing file", e);
|
|
}
|
|
}
|
|
|
|
private void readDictFromFile(final File file, final OnAddWordListener listener) {
|
|
FileInputStream inStream = null;
|
|
|
|
try {
|
|
inStream = new FileInputStream(file);
|
|
final byte[] buffer = new byte[(int)file.length()];
|
|
inStream.read(buffer);
|
|
|
|
UserHistoryDictIOUtils.readDictionaryBinary(
|
|
new UserHistoryDictIOUtils.ByteArrayWrapper(buffer), listener);
|
|
} catch (FileNotFoundException e) {
|
|
Log.e(TAG, "file not found", e);
|
|
} catch (IOException e) {
|
|
Log.e(TAG, "IOException", e);
|
|
} finally {
|
|
if (inStream != null) {
|
|
try {
|
|
inStream.close();
|
|
} catch (IOException e) {
|
|
// do nothing
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void testGenerateFusionDictionary() {
|
|
final UserHistoryDictionaryBigramList originalList = new UserHistoryDictionaryBigramList();
|
|
|
|
final HashMap<String, ArrayList<String> > addedWords =
|
|
new HashMap<String, ArrayList<String>>();
|
|
addBigramToBigramList("this", "is", addedWords, originalList);
|
|
addBigramToBigramList("this", "was", addedWords, originalList);
|
|
addBigramToBigramList("hello", "world", addedWords, originalList);
|
|
|
|
final FusionDictionary fusionDict =
|
|
UserHistoryDictIOUtils.constructFusionDictionary(this, originalList);
|
|
|
|
checkWordsInFusionDict(fusionDict, addedWords);
|
|
}
|
|
|
|
public void testReadAndWrite() {
|
|
final Context context = getContext();
|
|
|
|
File file = null;
|
|
try {
|
|
file = File.createTempFile("testReadAndWrite", ".dict", getContext().getCacheDir());
|
|
} catch (IOException e) {
|
|
Log.d(TAG, "IOException while creating a temporary file", e);
|
|
}
|
|
assertNotNull(file);
|
|
|
|
// make original dictionary
|
|
final UserHistoryDictionaryBigramList originalList = new UserHistoryDictionaryBigramList();
|
|
final HashMap<String, ArrayList<String>> addedWords = CollectionUtils.newHashMap();
|
|
addBigramToBigramList("this" , "is" , addedWords, originalList);
|
|
addBigramToBigramList("this" , "was" , addedWords, originalList);
|
|
addBigramToBigramList("is" , "not" , addedWords, originalList);
|
|
addBigramToBigramList("hello", "world", addedWords, originalList);
|
|
|
|
// write to file
|
|
writeDictToFile(file, originalList);
|
|
|
|
// make result dict.
|
|
final UserHistoryDictionaryBigramList resultList = new UserHistoryDictionaryBigramList();
|
|
final OnAddWordListener listener = new OnAddWordListener() {
|
|
@Override
|
|
public void setUnigram(final String word,
|
|
final String shortcutTarget, final int frequency) {
|
|
Log.d(TAG, "in: setUnigram: " + word + "," + frequency);
|
|
resultList.addBigram(null, word, (byte)frequency);
|
|
}
|
|
@Override
|
|
public void setBigram(final String word1, final String word2, final int frequency) {
|
|
Log.d(TAG, "in: setBigram: " + word1 + "," + word2 + "," + frequency);
|
|
resultList.addBigram(word1, word2, (byte)frequency);
|
|
}
|
|
};
|
|
|
|
// load from file
|
|
readDictFromFile(file, listener);
|
|
checkWordsInBigramList(resultList, addedWords);
|
|
|
|
// add new bigram
|
|
addBigramToBigramList("hello", "java", addedWords, resultList);
|
|
|
|
// rewrite
|
|
writeDictToFile(file, resultList);
|
|
final UserHistoryDictionaryBigramList resultList2 = new UserHistoryDictionaryBigramList();
|
|
final OnAddWordListener listener2 = new OnAddWordListener() {
|
|
@Override
|
|
public void setUnigram(final String word,
|
|
final String shortcutTarget, final int frequency) {
|
|
Log.d(TAG, "in: setUnigram: " + word + "," + frequency);
|
|
resultList2.addBigram(null, word, (byte)frequency);
|
|
}
|
|
@Override
|
|
public void setBigram(final String word1, final String word2, final int frequency) {
|
|
Log.d(TAG, "in: setBigram: " + word1 + "," + word2 + "," + frequency);
|
|
resultList2.addBigram(word1, word2, (byte)frequency);
|
|
}
|
|
};
|
|
|
|
// load from file
|
|
readDictFromFile(file, listener2);
|
|
checkWordsInBigramList(resultList2, addedWords);
|
|
}
|
|
}
|