inputmethod/latin/UserHistoryDictIOUtilsTests.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);
    }
}