// Copyright 2010-2015, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package org.mozc.android.inputmethod.japanese.userdictionary;

import static android.test.MoreAsserts.assertContentsInOrder;
import static android.test.MoreAsserts.assertEmpty;
import static org.easymock.EasyMock.expect;

import org.mozc.android.inputmethod.japanese.MozcUtil;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionary;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionary.Entry;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionary.PosType;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionaryCommand;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionaryCommand.CommandType;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionaryCommandStatus;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionaryCommandStatus.Builder;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionaryCommandStatus.Status;
import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionaryStorage;
import org.mozc.android.inputmethod.japanese.session.SessionExecutor;
import org.mozc.android.inputmethod.japanese.testing.InstrumentationTestCaseWithMock;
import org.mozc.android.inputmethod.japanese.testing.Parameter;
import com.google.common.base.Optional;
import com.google.common.base.Preconditions;

import android.content.Context;
import android.content.res.Configuration;
import android.content.res.Resources;
import android.net.Uri;
import android.test.suitebuilder.annotation.SmallTest;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.List;
import java.util.Locale;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipInputStream;

/**
 */
public class UserDictionaryToolModelTest extends InstrumentationTestCaseWithMock {
  @SmallTest
  public void testCreateSession() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.CREATE_SESSION)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setSessionId(100L)
            .build());
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.createSession();

    verifyAll();
    assertEquals(100L, model.sessionId);
  }

  @SmallTest
  public void testDeleteSession() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.DELETE_SESSION)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.deleteSession();

    verifyAll();
    assertEquals(0L, model.sessionId);
  }

  @SmallTest
  public void testResumeSession_success() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.NO_OPERATION)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.SET_DEFAULT_DICTIONARY_NAME)
            .setSessionId(100L)
            .setDictionaryName("default dictionary name")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.LOAD)
            .setSessionId(100L)
            .setEnsureNonEmptyStorage(true)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("User Dictionary 1")
                    .setId(1L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("User Dictionary 2")
                    .setId(2L)))
            .build());
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS,
                 model.resumeSession("default dictionary name"));
    verifyAll();

    assertContentsInOrder(model.getDictionaryNameList(), "User Dictionary 1", "User Dictionary 2");
    assertEquals(0, model.getSelectedDictionaryIndex());
  }

  @SmallTest
  public void testResumeSession_fileNotFound() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.NO_OPERATION)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.SET_DEFAULT_DICTIONARY_NAME)
            .setSessionId(100L)
            .setDictionaryName("default dictionary name")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.LOAD)
            .setSessionId(100L)
            .setEnsureNonEmptyStorage(true)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.FILE_NOT_FOUND)
            .build());
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("default dictionary name")
                    .setId(1L)))
            .build());
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;

    // Even if the file is not found, the load should be succeeded.
    // This is because it is expected case, e.g., in the first time launching of the tool.
    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS,
                 model.resumeSession("default dictionary name"));
    verifyAll();

    assertContentsInOrder(model.getDictionaryNameList(), "default dictionary name");
    assertEquals(0, model.getSelectedDictionaryIndex());
  }

  @SmallTest
  public void testResumeSession_failLoad() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.NO_OPERATION)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.SET_DEFAULT_DICTIONARY_NAME)
            .setSessionId(100L)
            .setDictionaryName("default dictionary name")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.UNKNOWN_ERROR)
            .build());

    // Regradless of whether the SET_DEFAULT_DICTIONARY_NAME is successfully done or not,
    // the load should be invoked.
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.LOAD)
            .setSessionId(100L)
            .setEnsureNonEmptyStorage(true)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.UNKNOWN_ERROR)
            .build());

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("default dictionary name")
                    .setId(1L)))
            .build());
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;

    assertEquals(Status.UNKNOWN_ERROR, model.resumeSession("default dictionary name"));
  }

  @SmallTest
  public void testResumeSession_retry() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.NO_OPERATION)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.UNKNOWN_SESSION_ID)
            .build());

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.CREATE_SESSION)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setSessionId(200L)
            .build());

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.SET_DEFAULT_DICTIONARY_NAME)
            .setSessionId(200L)
            .setDictionaryName("default dictionary name")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.UNKNOWN_ERROR)
            .build());

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.LOAD)
            .setSessionId(200L)
            .setEnsureNonEmptyStorage(true)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(200L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("User Dictionary 1")
                    .setId(1L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("User Dictionary 2")
                    .setId(2L)))
            .build());
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS,
                 model.resumeSession("default dictionary name"));
    verifyAll();

    assertContentsInOrder(model.getDictionaryNameList(), "User Dictionary 1", "User Dictionary 2");
    assertEquals(0, model.getSelectedDictionaryIndex());
  }

  @SmallTest
  public void testResumeSession_failGetDictionaryNameList() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.NO_OPERATION)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.SET_DEFAULT_DICTIONARY_NAME)
            .setSessionId(100L)
            .setDictionaryName("default dictionary name")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.LOAD)
            .setSessionId(100L)
            .setEnsureNonEmptyStorage(true)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.UNKNOWN_ERROR)
            .build());
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;

    // The loading itself is succeeded.
    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS,
                 model.resumeSession("default dictionary name"));
    verifyAll();

    assertEmpty(model.getDictionaryNameList());
    assertEquals(0, model.getSelectedDictionaryIndex());
  }

  @SmallTest
  public void testPauseSession_clean() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    // Do nothing for clean model.
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.dirty = false;  // Ensure it's clean.

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS, model.pauseSession());
    verifyAll();
  }

  @SmallTest
  public void testPauseSession_dirtyAndSuccess() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.SAVE)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    executor.reload();
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.dirty = true;  // Ensure it's dirty.

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS, model.pauseSession());
    verifyAll();
  }

  @SmallTest
  public void testPauseSession_dirtyAndFail() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.SAVE)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.UNKNOWN_ERROR)
            .build());
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.dirty = true;  // Ensure it's dirty.

    assertEquals(Status.UNKNOWN_ERROR, model.pauseSession());
    verifyAll();
  }

  @SmallTest
  public void testCheckUndoability() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.CHECK_UNDOABILITY)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    replayAll();

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS, model.checkUndoability());

    verifyAll();
  }

  @SmallTest
  public void testUndo() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.selectedDictionaryId = 400L;
    model.storage =
        UserDictionaryStorage.newBuilder()
            .addDictionaries(UserDictionary.newBuilder()
                .setId(400L))
            .addDictionaries(UserDictionary.newBuilder()
                .setId(500L))
            .build();

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.UNDO)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());

    // First case, returns the same dictionary name list.
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(400L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(500L)))
            .build());
    replayAll();

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS, model.undo());

    verifyAll();
    assertTrue(model.isDirty());
    assertEquals(0, model.getSelectedDictionaryIndex());

    model.dirty = false;
    resetAll();
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.UNDO)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());

    // Second case, returns a (deleted) dictionary is prepended.
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(300L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(400L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(500L)))
            .build());
    replayAll();

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS, model.undo());

    verifyAll();
    assertTrue(model.isDirty());
    assertEquals(1, model.getSelectedDictionaryIndex());

    model.dirty = false;
    resetAll();
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.UNDO)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());

    // Third case, the current selected dictionary is deleted. Keep the selected dictionary index.
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(300L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(500L)))
            .build());
    replayAll();

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS, model.undo());

    verifyAll();
    assertTrue(model.isDirty());
    assertEquals(1, model.getSelectedDictionaryIndex());
  }

  @SmallTest
  public void testUndo_fail() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.selectedDictionaryId = 400L;
    model.storage =
        UserDictionaryStorage.newBuilder()
            .addDictionaries(UserDictionary.newBuilder()
                .setId(400L))
            .addDictionaries(UserDictionary.newBuilder()
                .setId(500L))
            .build();

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.UNDO)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.NO_UNDO_HISTORY)
            .build());

    replayAll();

    assertEquals(Status.NO_UNDO_HISTORY, model.undo());

    verifyAll();
    assertFalse(model.isDirty());
    assertEquals(0, model.getSelectedDictionaryIndex());
  }

  @SmallTest
  public void testCheckNewDictionaryAvailability() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.CHECK_NEW_DICTIONARY_AVAILABILITY)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS, model.checkNewDictionaryAvailability());
    verifyAll();
  }

  @SmallTest
  public void testCreateDictionary_success() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.CREATE_DICTIONARY)
            .setSessionId(100L)
            .setDictionaryName("New User Dictionary")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setDictionaryId(500L)
            .build());

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("User Dictionary 1")
                    .setId(1L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("User Dictionary 2")
                    .setId(2L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("New User Dictionary")
                    .setId(500L)))
            .build());
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS,
                 model.createDictionary("New User Dictionary"));
    verifyAll();

    assertEquals(2, model.getSelectedDictionaryIndex());
    assertEquals("New User Dictionary", model.getSelectedDictionaryName());
    assertContentsInOrder(model.getDictionaryNameList(),
                          "User Dictionary 1",
                          "User Dictionary 2",
                          "New User Dictionary");
  }

  @SmallTest
  public void testCreateDictionary_fail() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.CREATE_DICTIONARY)
            .setSessionId(100L)
            .setDictionaryName("")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.DICTIONARY_NAME_EMPTY)
            .build());

    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;

    assertEquals(Status.DICTIONARY_NAME_EMPTY, model.createDictionary(""));
    verifyAll();
  }

  @SmallTest
  public void testRenameSelectedDictionary_success() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.RENAME_DICTIONARY)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .setDictionaryName("Another User Dictionary")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("User Dictionary 1")
                    .setId(1L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("User Dictionary 2")
                    .setId(2L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setName("Another User Dictionary")
                    .setId(500L)))
            .build());
    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.selectedDictionaryId = 500L;

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS,
                 model.renameSelectedDictionary("Another User Dictionary"));
    verifyAll();

    assertEquals(2, model.getSelectedDictionaryIndex());
    assertEquals("Another User Dictionary", model.getSelectedDictionaryName());
    assertContentsInOrder(model.getDictionaryNameList(),
                          "User Dictionary 1",
                          "User Dictionary 2",
                          "Another User Dictionary");
  }

  @SmallTest
  public void testRenameSelectedDictionary_fail() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.RENAME_DICTIONARY)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .setDictionaryName("")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.DICTIONARY_NAME_EMPTY)
            .build());

    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.selectedDictionaryId = 500L;

    assertEquals(Status.DICTIONARY_NAME_EMPTY, model.renameSelectedDictionary(""));
    verifyAll();
  }

  @SmallTest
  public void testDeleteSelectedDictionary_success() {
    SessionExecutor executor = createMock(SessionExecutor.class);

    class TestData extends Parameter {
      final UserDictionaryStorage storage;
      final int expectedSelectedDictionaryIndex;
      TestData(UserDictionaryStorage storage, int expectedSelectedDictionaryIndex) {
        this.storage = storage;
        this.expectedSelectedDictionaryIndex = expectedSelectedDictionaryIndex;
      }
    }

    TestData[] testDataList = {
        new TestData(
            UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(500L)
                    .setName("Target dictionary"))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(1L)
                    .setName("User Dictionary 1"))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(2L)
                    .setName("User Dictionary 2"))
                .build(),
            0),
        new TestData(
            UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(1L)
                    .setName("User Dictionary 1"))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(500L)
                    .setName("Target dictionary"))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(2L)
                    .setName("User Dictionary 2"))
                .build(),
            1),
        new TestData(
            UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(1L)
                    .setName("User Dictionary 1"))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(2L)
                    .setName("User Dictionary 2"))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(500L)
                    .setName("Target dictionary"))
                .build(),
            1),
    };

    for (TestData testData : testDataList) {
      resetAll();
      expect(executor.sendUserDictionaryCommand(
          UserDictionaryCommand.newBuilder()
              .setType(CommandType.DELETE_DICTIONARY)
              .setSessionId(100L)
              .setDictionaryId(500L)
              .setEnsureNonEmptyStorage(true)
              .build()))
          .andReturn(UserDictionaryCommandStatus.newBuilder()
              .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
              .build());

      expect(executor.sendUserDictionaryCommand(
          UserDictionaryCommand.newBuilder()
              .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
              .setSessionId(100L)
              .build()))
          .andReturn(UserDictionaryCommandStatus.newBuilder()
              .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
              .setStorage(UserDictionaryStorage.newBuilder()
                  .addDictionaries(UserDictionary.newBuilder()
                      .setName("User Dictionary 1")
                      .setId(1L))
                  .addDictionaries(UserDictionary.newBuilder()
                      .setName("User Dictionary 2")
                      .setId(2L)))
              .build());
      replayAll();

      UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
      model.sessionId = 100L;
      model.selectedDictionaryId = 500L;
      model.storage = testData.storage;

      assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS,
                   model.deleteSelectedDictionary());
      verifyAll();

      assertEquals(testData.expectedSelectedDictionaryIndex, model.getSelectedDictionaryIndex());
      assertContentsInOrder(model.getDictionaryNameList(),
                            "User Dictionary 1",
                            "User Dictionary 2");
    }
  }

  @SmallTest
  public void testDeleteSelectedDictionary_fail() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.DELETE_DICTIONARY)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .setEnsureNonEmptyStorage(true)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.UNKNOWN_DICTIONARY_ID)
            .build());

    replayAll();

    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.selectedDictionaryId = 500L;

    assertEquals(Status.UNKNOWN_DICTIONARY_ID, model.deleteSelectedDictionary());
    verifyAll();
  }

  @SmallTest
  public void testExportUserDictionary() throws IOException {
    class MockSessionExecutor extends SessionExecutor {

      private final int entrySize;

      MockSessionExecutor(int entrySize) {
        this.entrySize = entrySize;
      }

      @Override
      public UserDictionaryCommandStatus sendUserDictionaryCommand(UserDictionaryCommand command) {
        Preconditions.checkArgument(command.getSessionId() == 100L);
        Preconditions.checkArgument(command.getDictionaryId() == 500L);
        if (command.getType() == CommandType.GET_ENTRY_SIZE) {
          return UserDictionaryCommandStatus.newBuilder()
              .setEntrySize(entrySize)
              .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
              .build();
        } else if (command.getType() == CommandType.GET_ENTRIES) {
          Builder builder = UserDictionaryCommandStatus.newBuilder()
              .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS);
          for (int index : command.getEntryIndexList()) {
            Preconditions.checkElementIndex(index, entrySize);
            builder.addEntries(Entry.newBuilder()
                .setKey("よみ" + index)
                .setValue("漢字" + index)
                .setPos(PosType.SYMBOL)
                .setComment("comment" + index)
                .build());
          }
          return builder.build();
        }
        return UserDictionaryCommandStatus.newBuilder().setStatus(Status.INVALID_ARGUMENT).build();
      }
    }

    Context context = getInstrumentation().getTargetContext();
    Resources resources = context.getResources();
    File tempDirectory = MozcUtil.getUserDictionaryExportTempDirectory(context);
    Configuration config = resources.getConfiguration();
    Locale originalLocale = config.locale;

    try {
      for (Locale testLocale : new Locale[] {Locale.JAPANESE, Locale.ENGLISH}) {
        config.locale = testLocale;
        resources.updateConfiguration(config, resources.getDisplayMetrics());

        for (int entrySize : new int[] {0, 1, 10, 11, 100, 101, 1000, 1001, 10000}) {
          SessionExecutor executor = new MockSessionExecutor(entrySize);
          UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
          model.sessionId = 100L;
          model.selectedDictionaryId = 500L;

          Optional<File> exportFile = model.createExportFile(resources, "test", tempDirectory);
          assertTrue(exportFile.isPresent());

          ZipInputStream zipStream = null;
          BufferedReader reader = null;
          try {
            zipStream = new ZipInputStream(new FileInputStream(exportFile.get()));
            ZipEntry zipEntry = zipStream.getNextEntry();
            assertEquals("test.txt", zipEntry.getName());

            reader = new BufferedReader(new InputStreamReader(zipStream));
            for (int i = 0; i < entrySize; ++i) {
              String line = reader.readLine();
              assertEquals("よみ" + i + "\t漢字" + i + "\t記号\tcomment" + i, line);
            }
            assertNull(reader.readLine());
          } finally {
            if (reader != null) {
              MozcUtil.closeIgnoringIOException(reader);
            }
            if (zipStream != null) {
              MozcUtil.closeIgnoringIOException(zipStream);
            }
          }
        }
      }
    } finally {
      config.locale = originalLocale;
      resources.updateConfiguration(config, resources.getDisplayMetrics());
      MozcUtil.deleteDirectoryContents(tempDirectory);
      tempDirectory.delete();
    }
  }

  @SmallTest
  public void testGetEntryList() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    List<Entry> entryList = model.getEntryList();

    // Test without selected dictionary.
    resetAll();
    replayAll();
    assertEquals(0, entryList.size());
    verifyAll();

    // Test with selected dictionary.
    model.selectedDictionaryId = 500L;
    resetAll();
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_ENTRY_SIZE)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setEntrySize(10)
            .build());
    replayAll();
    assertEquals(10, entryList.size());
    verifyAll();

    resetAll();
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_ENTRIES)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .addEntryIndex(5)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .addEntries(Entry.newBuilder()
                .setKey("key")
                .setValue("value")
                .setPos(PosType.NOUN))
            .build());
    replayAll();
    Entry entry = entryList.get(5);

    verifyAll();
    assertEquals("key", entry.getKey());
    assertEquals("value", entry.getValue());
    assertEquals(PosType.NOUN, entry.getPos());
  }

  @SmallTest
  public void testEditTargetIndex() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.selectedDictionaryId = 500L;

    replayAll();
    model.setEditTargetIndex(10);
    assertEquals(10, model.getEditTargetIndex());
    verifyAll();

    resetAll();
    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_ENTRIES)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .addEntryIndex(10)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .addEntries(Entry.newBuilder()
                .setKey("key")
                .setValue("value")
                .setPos(PosType.NOUN))
            .build());
    replayAll();

    Entry entry = model.getEditTargetEntry();

    verifyAll();
    assertEquals("key", entry.getKey());
    assertEquals("value", entry.getValue());
    assertEquals(PosType.NOUN, entry.getPos());
  }

  @SmallTest
  public void testCheckNewEntryAvailability() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.selectedDictionaryId = 500L;

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.CHECK_NEW_ENTRY_AVAILABILITY)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    replayAll();

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS, model.checkNewEntryAvailability());

    verifyAll();
  }

  @SmallTest
  public void testAddEntry() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.selectedDictionaryId = 500L;

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.ADD_ENTRY)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .setEntry(Entry.newBuilder()
                .setKey("reading")
                .setValue("word")
                .setPos(PosType.NOUN))
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    replayAll();

    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS,
                 model.addEntry("word", "reading", PosType.NOUN));

    verifyAll();
    assertTrue(model.isDirty());
  }

  @SmallTest
  public void testEditEntry() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.selectedDictionaryId = 500L;

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.EDIT_ENTRY)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .addEntryIndex(5)
            .setEntry(Entry.newBuilder()
                .setKey("reading")
                .setValue("word")
                .setPos(PosType.NOUN))
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    replayAll();

    model.setEditTargetIndex(5);
    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS,
                 model.editEntry("word", "reading", PosType.NOUN));

    verifyAll();
    assertTrue(model.isDirty());
  }

  @SmallTest
  public void testDeleteEntry() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.selectedDictionaryId = 500L;

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.DELETE_ENTRY)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .addEntryIndex(5)
            .addEntryIndex(10)
            .addEntryIndex(100)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .build());
    replayAll();

    model.setEditTargetIndex(5);
    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS,
                 model.deleteEntry(Arrays.asList(5, 10, 100)));

    verifyAll();
    assertTrue(model.isDirty());
  }

  @SmallTest
  public void testResetImportState() {
    UserDictionaryToolModel model = new UserDictionaryToolModel(null);

    Uri uri = Uri.fromFile(new File("DUMMY/FILE"));
    String importData = "dummy import data";
    ZipFile zipFile = createMockBuilder(ZipFile.class)
        .withConstructor(String.class)
        .withArgs(getInstrumentation().getContext().getApplicationInfo().sourceDir)
        .createMock();

    try {
      zipFile.close();
    } catch (IOException e) {
      // Just ignore.
    }
    replayAll();

    model.setImportUri(uri);
    model.setImportData(importData);
    model.setZipFile(zipFile);

    assertSame(uri, model.getImportUri());
    assertSame(importData, model.getImportData());
    assertSame(zipFile, model.getZipFile());

    model.resetImportState();
    verifyAll();
    assertNull(model.getImportUri());
    assertNull(model.getImportData());
    assertNull(model.getZipFile());
  }

  @SmallTest
  public void testReleaseZipFile() {
    UserDictionaryToolModel model = new UserDictionaryToolModel(null);

    ZipFile zipFile = createMockBuilder(ZipFile.class)
        .withConstructor(String.class)
        .withArgs(getInstrumentation().getContext().getApplicationInfo().sourceDir)
        .createMock();

    replayAll();
    model.setZipFile(zipFile);
    assertSame(zipFile, model.getZipFile());
    assertSame(zipFile, model.releaseZipFile());
    assertNull(model.getZipFile());
    assertNull(model.releaseZipFile());
    verifyAll();

    resetAll();
    try {
      zipFile.close();
    } catch (IOException e) {
      // Just ignore.
    }
    replayAll();
    model.setZipFile(zipFile);
    model.setZipFile(null);
    verifyAll();
  }

  @SmallTest
  public void testImportData() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.storage =
        UserDictionaryStorage.newBuilder()
            .addDictionaries(UserDictionary.newBuilder()
                .setId(400L))
            .addDictionaries(UserDictionary.newBuilder()
                .setId(500L))
            .build();

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.IMPORT_DATA)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .setData("dummy import data")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setDictionaryId(500L)
            .build());

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(400L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(500L)))
            .build());
    replayAll();

    model.setImportUri(Uri.fromFile(new File("dummy/file")));
    model.setImportData("dummy import data");
    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS, model.importData(1));

    verifyAll();

    assertTrue(model.isDirty());
    assertEquals(1, model.getSelectedDictionaryIndex());
  }

  @SmallTest
  public void testImportDataToNewDictionary() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.storage =
        UserDictionaryStorage.newBuilder()
            .addDictionaries(UserDictionary.newBuilder()
                .setId(400L))
            .addDictionaries(UserDictionary.newBuilder()
                .setId(500L))
            .build();

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.IMPORT_DATA)
            .setSessionId(100L)
            .setDictionaryName("dummyfile")
            .setData("dummy import data")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setDictionaryId(600L)
            .build());

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(400L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(500L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(600L)))
            .build());
    replayAll();

    model.setImportUri(Uri.fromFile(new File("dummy_directory/dummyfile.zip")));
    model.setImportData("dummy import data");
    assertEquals(Status.USER_DICTIONARY_COMMAND_SUCCESS, model.importData(-1));

    verifyAll();

    assertTrue(model.isDirty());
    assertEquals(2, model.getSelectedDictionaryIndex());
  }

  @SmallTest
  public void testImportData_partiallySuccess() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.storage =
        UserDictionaryStorage.newBuilder()
            .addDictionaries(UserDictionary.newBuilder()
                .setId(400L))
            .addDictionaries(UserDictionary.newBuilder()
                .setId(500L))
            .build();

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.IMPORT_DATA)
            .setSessionId(100L)
            .setDictionaryName("dummyfile")
            .setData("dummy import data")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.IMPORT_INVALID_ENTRIES)
            .setDictionaryId(600L)
            .build());

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.GET_USER_DICTIONARY_NAME_LIST)
            .setSessionId(100L)
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.USER_DICTIONARY_COMMAND_SUCCESS)
            .setStorage(UserDictionaryStorage.newBuilder()
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(400L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(500L))
                .addDictionaries(UserDictionary.newBuilder()
                    .setId(600L)))
            .build());
    replayAll();

    model.setImportUri(Uri.fromFile(new File("dummy_directory/dummyfile.zip")));
    model.setImportData("dummy import data");
    assertEquals(Status.IMPORT_INVALID_ENTRIES, model.importData(-1));

    verifyAll();

    assertTrue(model.isDirty());
    assertEquals(2, model.getSelectedDictionaryIndex());
  }

  @SmallTest
  public void testImportData_failed() {
    SessionExecutor executor = createMock(SessionExecutor.class);
    UserDictionaryToolModel model = new UserDictionaryToolModel(executor);
    model.sessionId = 100L;
    model.selectedDictionaryId = 400L;
    model.dirty = false;
    model.storage =
        UserDictionaryStorage.newBuilder()
            .addDictionaries(UserDictionary.newBuilder()
                .setId(400L))
            .addDictionaries(UserDictionary.newBuilder()
                .setId(500L))
            .build();

    expect(executor.sendUserDictionaryCommand(
        UserDictionaryCommand.newBuilder()
            .setType(CommandType.IMPORT_DATA)
            .setSessionId(100L)
            .setDictionaryId(500L)
            .setData("dummy import data")
            .build()))
        .andReturn(UserDictionaryCommandStatus.newBuilder()
            .setStatus(Status.UNKNOWN_ERROR)
            .build());
    replayAll();

    model.setImportUri(Uri.fromFile(new File("dummy/file")));
    model.setImportData("dummy import data");
    assertEquals(Status.UNKNOWN_ERROR, model.importData(1));

    verifyAll();

    // Regardless of the result status, the dirty bit should be set.
    assertTrue(model.isDirty());
    assertEquals(0, model.getSelectedDictionaryIndex());
  }
}