| // 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.session; |
| |
| import static org.mozc.android.inputmethod.japanese.testing.MozcMatcher.matchesBuilder; |
| import static org.mozc.android.inputmethod.japanese.testing.MozcMatcher.sameOptional; |
| import static org.easymock.EasyMock.anyLong; |
| import static org.easymock.EasyMock.capture; |
| import static org.easymock.EasyMock.expect; |
| import static org.easymock.EasyMock.getCurrentArguments; |
| import static org.easymock.EasyMock.same; |
| |
| import org.mozc.android.inputmethod.japanese.KeycodeConverter; |
| import org.mozc.android.inputmethod.japanese.KeycodeConverter.KeyEventInterface; |
| import org.mozc.android.inputmethod.japanese.preference.ClientSidePreference.KeyboardLayout; |
| import org.mozc.android.inputmethod.japanese.preference.PreferenceUtil; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCandidates.CandidateList; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCandidates.CandidateWord; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Capability; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Capability.TextDeletionCapabilityType; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Command; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.CompositionMode; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Context.InputFieldType; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.DeletionRange; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.GenericStorageEntry; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.GenericStorageEntry.StorageType; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Input; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Input.CommandType; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Input.TouchEvent; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.KeyEvent.SpecialKey; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Output; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Request; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Result; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Result.ResultType; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.SessionCommand; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.SessionCommand.UsageStatsEvent; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoConfig.Config; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionaryCommand; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoUserDictionaryStorage.UserDictionaryCommandStatus; |
| import org.mozc.android.inputmethod.japanese.session.SessionExecutor.AsynchronousEvaluationContext; |
| import org.mozc.android.inputmethod.japanese.session.SessionExecutor.CallbackHandler; |
| import org.mozc.android.inputmethod.japanese.session.SessionExecutor.EvaluationCallback; |
| import org.mozc.android.inputmethod.japanese.session.SessionExecutor.ExecutorMainCallback; |
| import org.mozc.android.inputmethod.japanese.session.SessionExecutor.SynchronousEvaluationContext; |
| import org.mozc.android.inputmethod.japanese.stresstest.StressTest; |
| import org.mozc.android.inputmethod.japanese.testing.InstrumentationTestCaseWithMock; |
| import org.mozc.android.inputmethod.japanese.testing.MemoryLogger; |
| import org.mozc.android.inputmethod.japanese.testing.Parameter; |
| import com.google.common.base.Optional; |
| import com.google.common.base.Strings; |
| import com.google.protobuf.ByteString; |
| |
| import android.content.Context; |
| import android.content.SharedPreferences; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.preference.PreferenceManager; |
| import android.test.mock.MockContext; |
| import android.test.suitebuilder.annotation.LargeTest; |
| import android.test.suitebuilder.annotation.SmallTest; |
| import android.view.KeyEvent; |
| |
| import org.easymock.Capture; |
| import org.easymock.IAnswer; |
| |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Random; |
| import java.util.concurrent.CountDownLatch; |
| |
| /** |
| * |
| */ |
| public class SessionExecutorTest extends InstrumentationTestCaseWithMock { |
| |
| private SessionExecutor createSessionExecutorMock() { |
| return createMockBuilder(SessionExecutor.class) |
| .addMockedMethods("evaluateSynchronously", "evaluateAsynchronously") |
| .createMock(); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| SessionExecutor.instance = Optional.absent(); |
| super.tearDown(); |
| } |
| |
| @SmallTest |
| public void testGetInstanceInitializedIfNecessary() { |
| Context context = new MockContext(); |
| SessionHandlerFactory factory = createMockBuilder(SessionHandlerFactory.class) |
| .withConstructor(Context.class) |
| .withArgs(getInstrumentation().getTargetContext()) |
| .createMock(); |
| SessionHandler mockHandler = createNiceMock(SessionHandler.class); |
| expect(factory.create()).andReturn(mockHandler); |
| replayAll(); |
| |
| SessionExecutor instance = SessionExecutor.getInstanceInitializedIfNecessary(factory, context); |
| |
| verifyAll(); |
| |
| // We don't expect re-setting up for the second time. |
| resetAll(); |
| replayAll(); |
| |
| SessionExecutor instance2 = SessionExecutor.getInstanceInitializedIfNecessary(factory, context); |
| |
| verifyAll(); |
| |
| // The same instance should be returned. |
| assertSame(instance, instance2); |
| } |
| |
| @SmallTest |
| public void testCallbackInitializeSessionHandler() { |
| Context context = getInstrumentation().getContext(); |
| SessionHandler sessionHandler = createMock(SessionHandler.class); |
| sessionHandler.initialize(context); |
| replayAll(); |
| |
| ExecutorMainCallback callback = new ExecutorMainCallback(sessionHandler); |
| Message message = new Message(); |
| message.obj = Object.class.cast(context); |
| message.what = ExecutorMainCallback.INITIALIZE_SESSION_HANDLER; |
| assertTrue(callback.handleMessage(message)); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testCallbackEnsureSession() { |
| SessionHandler sessionHandler = createMock(SessionHandler.class); |
| long sessionId = 1; |
| Request initialRequest = Request.newBuilder() |
| .setMixedConversion(true) |
| .setZeroQuerySuggestion(true) |
| .setAutoPartialSuggestion(true) |
| .setUpdateInputModeFromSurroundingText(false) |
| .build(); |
| { |
| // Create session. |
| Input input = Input.newBuilder() |
| .setType(CommandType.CREATE_SESSION) |
| .setCapability(Capability.newBuilder() |
| .setTextDeletion(TextDeletionCapabilityType.DELETE_PRECEDING_TEXT)) |
| .build(); |
| Command inputCommand = Command.newBuilder() |
| .setInput(input).setOutput(Output.getDefaultInstance()).build(); |
| Command outputCommand = Command.newBuilder() |
| .setInput(input).setOutput(Output.newBuilder().setId(sessionId)).build(); |
| expect(sessionHandler.evalCommand(inputCommand)).andReturn(outputCommand); |
| } |
| { |
| // Set request. |
| Command inputCommand = Command.newBuilder() |
| .setInput(Input.newBuilder() |
| .setId(sessionId) |
| .setType(CommandType.SET_REQUEST) |
| .setRequest(initialRequest)) |
| .setOutput(Output.getDefaultInstance()) |
| .build(); |
| expect(sessionHandler.evalCommand(inputCommand)).andReturn(Command.getDefaultInstance()); |
| } |
| replayAll(); |
| |
| ExecutorMainCallback callback = new ExecutorMainCallback(sessionHandler); |
| callback.ensureSession(); |
| |
| verifyAll(); |
| |
| resetAll(); |
| { |
| // After createSession, sessionId and request should be automatically filled, for update() |
| // method. |
| Command inputCommand = Command.newBuilder() |
| .setInput(Input.newBuilder() |
| .setId(sessionId) |
| .setType(CommandType.SET_REQUEST) |
| .setRequest(initialRequest)) |
| .setOutput(Output.getDefaultInstance()) |
| .build(); |
| expect(sessionHandler.evalCommand(inputCommand)).andReturn(Command.getDefaultInstance()); |
| } |
| replayAll(); |
| |
| callback.updateRequest(Input.newBuilder()); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testCallbackIsSquashable() { |
| Output squashableOutput = Output.newBuilder() |
| .setConsumed(true) |
| .setAllCandidateWords(CandidateList.newBuilder() |
| .addCandidates(CandidateWord.getDefaultInstance())) |
| .build(); |
| |
| assertTrue(ExecutorMainCallback.isSquashableOutput(squashableOutput)); |
| assertFalse(ExecutorMainCallback.isSquashableOutput(squashableOutput.toBuilder() |
| .setResult(Result.newBuilder().setType(ResultType.NONE).setValue("abc")) |
| .build())); |
| assertFalse(ExecutorMainCallback.isSquashableOutput(squashableOutput.toBuilder() |
| .setDeletionRange(DeletionRange.getDefaultInstance()) |
| .build())); |
| assertFalse(ExecutorMainCallback.isSquashableOutput(squashableOutput.toBuilder() |
| .setConsumed(false) |
| .build())); |
| assertFalse(ExecutorMainCallback.isSquashableOutput(squashableOutput.toBuilder() |
| .clearAllCandidateWords() |
| .build())); |
| assertFalse(ExecutorMainCallback.isSquashableOutput(Output.getDefaultInstance())); |
| } |
| |
| @SmallTest |
| public void testIsSessionIdRequired() { |
| assertFalse(ExecutorMainCallback.isSessionIdRequired(Input.newBuilder() |
| .setType(CommandType.SET_CONFIG))); |
| assertFalse(ExecutorMainCallback.isSessionIdRequired(Input.newBuilder() |
| .setType(CommandType.SET_IMPOSED_CONFIG))); |
| assertFalse(ExecutorMainCallback.isSessionIdRequired(Input.newBuilder() |
| .setType(CommandType.GET_CONFIG))); |
| |
| assertTrue(ExecutorMainCallback.isSessionIdRequired(Input.newBuilder() |
| .setType(CommandType.SEND_KEY))); |
| assertTrue(ExecutorMainCallback.isSessionIdRequired(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND))); |
| } |
| |
| @SmallTest |
| public void testCallbackEvaluateAsynchronously() { |
| class TestData extends Parameter { |
| final Output output; |
| final boolean expectRequestSuggestion; |
| final int expectedWhat; |
| TestData(Output output, boolean expectRequestSuggestion, int expectedWhat) { |
| this.output = output; |
| this.expectRequestSuggestion = expectRequestSuggestion; |
| this.expectedWhat = expectedWhat; |
| } |
| } |
| TestData[] testData = new TestData[] { |
| new TestData(Output.newBuilder() |
| .setConsumed(true) |
| .setAllCandidateWords(CandidateList.newBuilder() |
| .addCandidates(CandidateWord.getDefaultInstance())) |
| .build(), |
| true, |
| CallbackHandler.SQUASHABLE_OUTPUT), |
| new TestData(Output.getDefaultInstance(), true, CallbackHandler.UNSQUASHABLE_OUTPUT), |
| new TestData(Output.newBuilder() |
| .setConsumed(true) |
| .setAllCandidateWords(CandidateList.newBuilder() |
| .addCandidates(CandidateWord.getDefaultInstance())) |
| .build(), |
| false, |
| CallbackHandler.SQUASHABLE_OUTPUT), |
| new TestData(Output.getDefaultInstance(), false, CallbackHandler.UNSQUASHABLE_OUTPUT), |
| }; |
| Handler callbackHandler = createMock(Handler.class); |
| Handler currentHandler = new Handler(); |
| SessionHandler sessionHandler = createMock(SessionHandler.class); |
| for (TestData data : testData) { |
| resetAll(); |
| |
| Input.Builder inputBuilder = Input.newBuilder() |
| .setType(CommandType.SEND_KEY) |
| .setKey(ProtoCommands.KeyEvent.newBuilder() |
| .setSpecialKey(SpecialKey.BACKSPACE)); |
| |
| // Unfortunately we cannot mock the removeMessages because it is final method. Just skip it. |
| |
| // Note that Handler#obtainMessage and Handler#sendMessage cannot be mocked. |
| // So, we just mock sendMessageAtTime method instead. |
| Capture<Message> messageCapture = new Capture<Message>(); |
| expect(callbackHandler.sendMessageAtTime(capture(messageCapture), anyLong())).andReturn(true); |
| |
| AsynchronousEvaluationContext context = new AsynchronousEvaluationContext( |
| 0, inputBuilder, Optional.<KeyEventInterface>absent(), |
| Optional.<EvaluationCallback>absent(), Optional.of(callbackHandler)); |
| long sessionId = 1; |
| |
| { |
| Input.Builder builder = inputBuilder.clone(); |
| builder.setId(sessionId); |
| if (!data.expectRequestSuggestion) { |
| builder.setRequestSuggestion(false); |
| } |
| Command inputCommand = Command.newBuilder() |
| .setInput(builder) |
| .setOutput(Output.getDefaultInstance()) |
| .build(); |
| expect(sessionHandler.evalCommand(inputCommand)).andReturn(Command.newBuilder() |
| .setInput(inputCommand.getInput()) |
| .setOutput(data.output) |
| .build()); |
| } |
| |
| if (!data.expectRequestSuggestion) { |
| currentHandler.sendEmptyMessage(ExecutorMainCallback.EVALUATE_KEYEVENT_ASYNCHRONOUSLY); |
| } |
| replayAll(); |
| |
| ExecutorMainCallback callback = new ExecutorMainCallback(sessionHandler); |
| callback.sessionId = sessionId; |
| |
| callback.evaluateAsynchronously(context, currentHandler); |
| |
| verifyAll(); |
| Message message = messageCapture.getValue(); |
| assertEquals(data.expectedWhat, message.what); |
| assertSame(context, message.obj); |
| assertTrue(context.outCommand.isPresent()); |
| currentHandler.removeMessages(ExecutorMainCallback.EVALUATE_KEYEVENT_ASYNCHRONOUSLY); |
| } |
| } |
| |
| @SmallTest |
| public void testCallbackEvaluateSynchronously() { |
| Input input = Input.newBuilder().setType(Input.CommandType.GET_CONFIG).build(); |
| CountDownLatch countDownLatch = new CountDownLatch(1); |
| |
| SynchronousEvaluationContext context = new SynchronousEvaluationContext(input, countDownLatch); |
| |
| SessionHandler sessionHandler = createMock(SessionHandler.class); |
| { |
| Command inputCommand = Command.newBuilder() |
| .setInput(input).setOutput(Output.getDefaultInstance()).build(); |
| expect(sessionHandler.evalCommand(inputCommand)).andReturn(Command.getDefaultInstance()); |
| } |
| replayAll(); |
| |
| ExecutorMainCallback callback = new ExecutorMainCallback(sessionHandler); |
| |
| callback.evaluateSynchronously(context); |
| |
| verifyAll(); |
| assertEquals(0, countDownLatch.getCount()); |
| assertTrue(context.outCommand.isPresent()); |
| } |
| |
| @SmallTest |
| public void testCallbackUpdateRequest() { |
| Request.Builder initialRequest = |
| Request.newBuilder().setMixedConversion(true).setZeroQuerySuggestion(true); |
| Request diffRequest = Request.newBuilder().setZeroQuerySuggestion(false).build(); |
| Request updatedRequest = initialRequest.clone().mergeFrom(diffRequest).build(); |
| long sessionId = 1; |
| List<TouchEvent> touchEventList = Collections.singletonList(TouchEvent.getDefaultInstance()); |
| |
| SessionHandler sessionHandler = createMock(SessionHandler.class); |
| { |
| Command inputCommand = Command.newBuilder() |
| .setInput(Input.newBuilder() |
| .setId(sessionId) |
| .setType(CommandType.SET_REQUEST) |
| .setRequest(updatedRequest) |
| .addAllTouchEvents(touchEventList)) |
| .setOutput(Output.getDefaultInstance()) |
| .build(); |
| expect(sessionHandler.evalCommand(inputCommand)).andReturn(Command.getDefaultInstance()); |
| } |
| replayAll(); |
| |
| ExecutorMainCallback callback = new ExecutorMainCallback(sessionHandler); |
| callback.sessionId = sessionId; |
| callback.request = Optional.of(initialRequest); |
| |
| callback.updateRequest( |
| Input.newBuilder().setRequest(diffRequest).addAllTouchEvents(touchEventList)); |
| |
| verifyAll(); |
| resetAll(); |
| { |
| // Make sure that internal request is also updated by invoking updateRequest again. |
| Command inputCommand = Command.newBuilder() |
| .setInput(Input.newBuilder() |
| .setId(sessionId) |
| .setType(CommandType.SET_REQUEST) |
| .setRequest(initialRequest)) |
| .setOutput(Output.getDefaultInstance()) |
| .build(); |
| expect(sessionHandler.evalCommand(inputCommand)).andReturn(Command.getDefaultInstance()); |
| } |
| replayAll(); |
| callback.updateRequest(Input.newBuilder()); |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testCallbackHandler() { |
| CallbackHandler callbackHandler = new CallbackHandler(Looper.myLooper()); |
| callbackHandler.cancelTimeStamp = 0; |
| |
| EvaluationCallback evaluationCallback = createMock(EvaluationCallback.class); |
| evaluationCallback.onCompleted( |
| Optional.<Command>absent(), Optional.<KeyEventInterface>absent()); |
| replayAll(); |
| |
| AsynchronousEvaluationContext context = new AsynchronousEvaluationContext( |
| 1, Input.newBuilder(), Optional.<KeyEventInterface>absent(), |
| Optional.of(evaluationCallback), Optional.<Handler>of(callbackHandler)); |
| Message message = callbackHandler.obtainMessage(CallbackHandler.UNSQUASHABLE_OUTPUT, context); |
| callbackHandler.handleMessage(message); |
| |
| verifyAll(); |
| |
| resetAll(); |
| replayAll(); |
| |
| callbackHandler.cancelTimeStamp = 1; |
| callbackHandler.handleMessage(message); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testDeleteSession() { |
| Capture<Message> messageCapture = new Capture<Message>(); |
| Handler handler = createMock(Handler.class); |
| expect(handler.sendMessageAtTime(capture(messageCapture), anyLong())).andReturn(true); |
| replayAll(); |
| |
| SessionExecutor executor = new SessionExecutor(); |
| executor.handler = Optional.of(handler); |
| |
| executor.deleteSession(); |
| |
| verifyAll(); |
| assertEquals(ExecutorMainCallback.DELETE_SESSION, messageCapture.getValue().what); |
| } |
| |
| @SmallTest |
| public void testEvaluateAsynchronously() { |
| Capture<Message> messageCapture = new Capture<Message>(); |
| Handler handler = createMock(Handler.class); |
| expect(handler.sendMessageAtTime(capture(messageCapture), anyLong())).andReturn(true); |
| replayAll(); |
| |
| SessionExecutor executor = new SessionExecutor(); |
| executor.handler = Optional.of(handler); |
| |
| Input.Builder inputBuilder = Input.newBuilder(); |
| KeyEventInterface keyEvent = KeycodeConverter.getKeyEventInterface(KeyEvent.KEYCODE_A); |
| |
| executor.evaluateAsynchronously( |
| inputBuilder, Optional.of(keyEvent), Optional.<EvaluationCallback>absent()); |
| |
| verifyAll(); |
| Message message = messageCapture.getValue(); |
| assertEquals(ExecutorMainCallback.EVALUATE_KEYEVENT_ASYNCHRONOUSLY, message.what); |
| AsynchronousEvaluationContext context = AsynchronousEvaluationContext.class.cast(message.obj); |
| assertSame(inputBuilder, context.inputBuilder); |
| assertSame(keyEvent, context.triggeringKeyEvent.get()); |
| assertFalse(context.callback.isPresent()); |
| assertFalse(context.callbackHandler.isPresent()); |
| } |
| |
| @SmallTest |
| public void testEvaluateAsynchronously_withoutKeyEvent() { |
| Capture<Message> messageCapture = new Capture<Message>(); |
| Handler handler = createMock(Handler.class); |
| expect(handler.sendMessageAtTime(capture(messageCapture), anyLong())).andReturn(true); |
| replayAll(); |
| |
| SessionExecutor executor = new SessionExecutor(); |
| executor.handler = Optional.of(handler); |
| |
| Input.Builder inputBuilder = Input.newBuilder(); |
| |
| executor.evaluateAsynchronously( |
| inputBuilder, Optional.<KeyEventInterface>absent(), Optional.<EvaluationCallback>absent()); |
| |
| verifyAll(); |
| Message message = messageCapture.getValue(); |
| assertEquals(ExecutorMainCallback.EVALUATE_ASYNCHRONOUSLY, message.what); |
| AsynchronousEvaluationContext context = AsynchronousEvaluationContext.class.cast(message.obj); |
| assertSame(inputBuilder, context.inputBuilder); |
| assertFalse(context.triggeringKeyEvent.isPresent()); |
| assertFalse(context.callback.isPresent()); |
| assertFalse(context.callbackHandler.isPresent()); |
| } |
| |
| @SmallTest |
| public void testEvaluateSynchronously() { |
| Capture<Message> messageCapture = new Capture<Message>(); |
| Handler handler = createMock(Handler.class); |
| |
| // This emulates "accept message sent via handler, pseudo-execute of |
| // SessionHandlerCallback#evaluateSynchronously on this thread (instead of the worker thread) |
| // for synchronization purpose, and then return true as sendMessage's return value". |
| IAnswer<Boolean> mockExecutor = new IAnswer<Boolean>() { |
| @Override |
| public Boolean answer() throws Throwable { |
| // Emulate synchronous evaluation. |
| Message message = Message.class.cast(getCurrentArguments()[0]); |
| SynchronousEvaluationContext context = |
| SynchronousEvaluationContext.class.cast(message.obj); |
| context.outCommand = Optional.of(Command.newBuilder() |
| .setInput(Input.newBuilder().setType(CommandType.NO_OPERATION).build()) |
| .setOutput(Output.getDefaultInstance()) |
| .build()); |
| context.evaluationSynchronizer.countDown(); |
| return Boolean.TRUE; |
| } |
| }; |
| expect(handler.sendMessageAtTime(capture(messageCapture), anyLong())).andAnswer(mockExecutor); |
| replayAll(); |
| |
| SessionExecutor executor = new SessionExecutor(); |
| executor.handler = Optional.of(handler); |
| |
| executor.evaluateSynchronously(Input.getDefaultInstance()); |
| |
| verifyAll(); |
| assertEquals(ExecutorMainCallback.EVALUATE_SYNCHRONOUSLY, messageCapture.getValue().what); |
| } |
| |
| @SmallTest |
| public void testSendKey() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| ProtoCommands.KeyEvent mozcKeyEvent = ProtoCommands.KeyEvent.getDefaultInstance(); |
| KeyEventInterface triggeringKeyEvent = |
| KeycodeConverter.getKeyEventInterface(KeyEvent.KEYCODE_A); |
| EvaluationCallback evaluationCallback = createNiceMock(EvaluationCallback.class); |
| List<TouchEvent> touchEventList = Collections.singletonList(TouchEvent.getDefaultInstance()); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_KEY) |
| .setKey(mozcKeyEvent) |
| .addAllTouchEvents(touchEventList)), |
| sameOptional(triggeringKeyEvent), |
| sameOptional(evaluationCallback)); |
| replayAll(); |
| |
| executor.sendKey(mozcKeyEvent, triggeringKeyEvent, touchEventList, evaluationCallback); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testSubmit() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| EvaluationCallback evaluationCallback = createNiceMock(EvaluationCallback.class); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.SUBMIT))), |
| same(Optional.<KeyEventInterface>absent()), sameOptional(evaluationCallback)); |
| replayAll(); |
| |
| executor.submit(evaluationCallback); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testSwitchInputMode() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| EvaluationCallback callback = createNiceMock(EvaluationCallback.class); |
| |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.SWITCH_INPUT_MODE) |
| .setCompositionMode(CompositionMode.DIRECT))), |
| same(Optional.<KeyEventInterface>absent()), sameOptional(callback)); |
| replayAll(); |
| |
| executor.switchInputMode( |
| Optional.<KeyEventInterface>absent(), CompositionMode.DIRECT, callback); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testSubmitCandidate() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| EvaluationCallback evaluationCallback = createNiceMock(EvaluationCallback.class); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.SUBMIT_CANDIDATE) |
| .setId(3))), |
| same(Optional.<KeyEventInterface>absent()), sameOptional(evaluationCallback)); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.USAGE_STATS_EVENT) |
| .setUsageStatsEvent(UsageStatsEvent.SUBMITTED_CANDIDATE_ROW_GE10))), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| replayAll(); |
| |
| executor.submitCandidate(3, Optional.<Integer>of(100), evaluationCallback); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testResetContext() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.RESET_CONTEXT))), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| replayAll(); |
| |
| executor.resetContext(); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testMoveCursor() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| EvaluationCallback evaluationCallback = createNiceMock(EvaluationCallback.class); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand( |
| SessionCommand.newBuilder() |
| .setType(ProtoCommands.SessionCommand.CommandType.MOVE_CURSOR) |
| .setCursorPosition(5))), |
| same(Optional.<KeyEventInterface>absent()), sameOptional(evaluationCallback)); |
| replayAll(); |
| |
| executor.moveCursor(5, evaluationCallback); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testPageDownAndUp() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| EvaluationCallback evaluationCallback = createNiceMock(EvaluationCallback.class); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(ProtoCommands.SessionCommand.CommandType.CONVERT_NEXT_PAGE))), |
| same(Optional.<KeyEventInterface>absent()), sameOptional(evaluationCallback)); |
| replayAll(); |
| executor.pageDown(evaluationCallback); |
| verifyAll(); |
| |
| resetAll(); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(ProtoCommands.SessionCommand.CommandType.CONVERT_PREV_PAGE))), |
| same(Optional.<KeyEventInterface>absent()), sameOptional(evaluationCallback)); |
| replayAll(); |
| executor.pageUp(evaluationCallback); |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testSwitchInputFieldType() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.SWITCH_INPUT_FIELD_TYPE)) |
| .setContext(ProtoCommands.Context.newBuilder() |
| .setInputFieldType(InputFieldType.NORMAL))), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| replayAll(); |
| |
| executor.switchInputFieldType(InputFieldType.NORMAL); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testUndoOrRewind() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| EvaluationCallback evaluationCallback = createNiceMock(EvaluationCallback.class); |
| List<TouchEvent> touchEventList = Collections.singletonList(TouchEvent.getDefaultInstance()); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.UNDO_OR_REWIND)) |
| .addAllTouchEvents(touchEventList)), |
| same(Optional.<KeyEventInterface>absent()), sameOptional(evaluationCallback)); |
| replayAll(); |
| |
| executor.undoOrRewind(touchEventList, evaluationCallback); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testInsertToStorage() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.INSERT_TO_STORAGE) |
| .setStorageEntry(GenericStorageEntry.newBuilder() |
| .setType(StorageType.EMOTICON_HISTORY) |
| .setKey("TEST_KEY") |
| .addAllValue(Collections.singletonList(ByteString.copyFromUtf8("TEST_VALUE"))))), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| replayAll(); |
| |
| executor.insertToStorage( |
| StorageType.EMOTICON_HISTORY, "TEST_KEY", |
| Collections.singletonList(ByteString.copyFromUtf8("TEST_VALUE"))); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testExpandSuggestion() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| EvaluationCallback evaluationCallback = createNiceMock(EvaluationCallback.class); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand( |
| SessionCommand.newBuilder().setType(SessionCommand.CommandType.EXPAND_SUGGESTION))), |
| same(Optional.<KeyEventInterface>absent()), sameOptional(evaluationCallback)); |
| replayAll(); |
| |
| executor.expandSuggestion(evaluationCallback); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testPreferenceUsageStatsEvent() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| |
| Context context = getInstrumentation().getContext(); |
| Context targetContext = getInstrumentation().getTargetContext(); |
| SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context); |
| assertNotNull(sharedPreferences); |
| |
| sharedPreferences.edit() |
| .putString(PreferenceUtil.PREF_LANDSCAPE_KEYBOARD_LAYOUT_KEY, KeyboardLayout.GODAN.name()) |
| .putString(PreferenceUtil.PREF_PORTRAIT_KEYBOARD_LAYOUT_KEY, KeyboardLayout.QWERTY.name()) |
| .putBoolean(PreferenceUtil.PREF_USE_PORTRAIT_KEYBOARD_SETTINGS_FOR_LANDSCAPE_KEY, false) |
| .commit(); |
| |
| resetAll(); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.USAGE_STATS_EVENT) |
| .setUsageStatsEvent(UsageStatsEvent.SOFTWARE_KEYBOARD_LAYOUT_LANDSCAPE) |
| .setUsageStatsEventIntValue(KeyboardLayout.GODAN.getId()))), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.USAGE_STATS_EVENT) |
| .setUsageStatsEvent(UsageStatsEvent.SOFTWARE_KEYBOARD_LAYOUT_PORTRAIT) |
| .setUsageStatsEventIntValue(KeyboardLayout.QWERTY.getId()))), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| replayAll(); |
| executor.preferenceUsageStatsEvent(sharedPreferences, targetContext.getResources()); |
| verifyAll(); |
| |
| sharedPreferences.edit() |
| .putBoolean(PreferenceUtil.PREF_USE_PORTRAIT_KEYBOARD_SETTINGS_FOR_LANDSCAPE_KEY, true) |
| .commit(); |
| |
| resetAll(); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.USAGE_STATS_EVENT) |
| .setUsageStatsEvent(UsageStatsEvent.SOFTWARE_KEYBOARD_LAYOUT_LANDSCAPE) |
| .setUsageStatsEventIntValue(KeyboardLayout.QWERTY.getId()))), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.USAGE_STATS_EVENT) |
| .setUsageStatsEvent(UsageStatsEvent.SOFTWARE_KEYBOARD_LAYOUT_PORTRAIT) |
| .setUsageStatsEventIntValue(KeyboardLayout.QWERTY.getId()))), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| replayAll(); |
| executor.preferenceUsageStatsEvent(sharedPreferences, targetContext.getResources()); |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testTouchEventUsageStatsEvent() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| |
| List<TouchEvent> touchEventList = Collections.singletonList(TouchEvent.getDefaultInstance()); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SEND_COMMAND) |
| .setCommand(SessionCommand.newBuilder() |
| .setType(SessionCommand.CommandType.USAGE_STATS_EVENT)) |
| .addAllTouchEvents(touchEventList)), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| replayAll(); |
| |
| executor.touchEventUsageStatsEvent(touchEventList); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testSyncData() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SYNC_DATA)), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| replayAll(); |
| |
| executor.syncData(); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testGetConfig() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| |
| Config outputConfig = Config.newBuilder().build(); |
| expect(executor.evaluateSynchronously( |
| Input.newBuilder().setType(Input.CommandType.GET_CONFIG).build())) |
| .andReturn(Output.newBuilder().setConfig(outputConfig).build()); |
| replayAll(); |
| |
| assertSame(outputConfig, executor.getConfig()); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testSetConfig() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| |
| Config inputConfig = Config.newBuilder().build(); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SET_CONFIG) |
| .setConfig(inputConfig)), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| replayAll(); |
| |
| executor.setConfig(inputConfig); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testSetImposedConfig() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| |
| Config inputConfig = Config.newBuilder().build(); |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.SET_IMPOSED_CONFIG) |
| .setConfig(inputConfig)), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| replayAll(); |
| |
| executor.setImposedConfig(inputConfig); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testClearUnusedUserPrediction() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| expect(executor.evaluateSynchronously( |
| Input.newBuilder() |
| .setType(Input.CommandType.CLEAR_UNUSED_USER_PREDICTION) |
| .build())) |
| .andReturn(Output.getDefaultInstance()); |
| replayAll(); |
| |
| executor.clearUnusedUserPrediction(); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testClearUserHistory() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| expect(executor.evaluateSynchronously( |
| Input.newBuilder() |
| .setType(Input.CommandType.CLEAR_USER_HISTORY) |
| .build())) |
| .andReturn(Output.getDefaultInstance()); |
| replayAll(); |
| |
| executor.clearUserHistory(); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testClearUserPrediction() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| expect(executor.evaluateSynchronously( |
| Input.newBuilder() |
| .setType(Input.CommandType.CLEAR_USER_PREDICTION) |
| .build())) |
| .andReturn(Output.getDefaultInstance()); |
| replayAll(); |
| |
| executor.clearUserPrediction(); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testClearStorage() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| expect(executor.evaluateSynchronously( |
| Input.newBuilder() |
| .setType(Input.CommandType.CLEAR_STORAGE) |
| .setStorageEntry(GenericStorageEntry.newBuilder().setType(StorageType.EMOJI_HISTORY)) |
| .build())) |
| .andReturn(Output.getDefaultInstance()); |
| replayAll(); |
| |
| executor.clearStorage(StorageType.EMOJI_HISTORY); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testReadAllFromStorage() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| expect(executor.evaluateSynchronously( |
| Input.newBuilder() |
| .setType(CommandType.READ_ALL_FROM_STORAGE) |
| .setStorageEntry(GenericStorageEntry.newBuilder() |
| .setType(StorageType.EMOTICON_HISTORY)) |
| .build())) |
| .andReturn(Output.newBuilder() |
| .setStorageEntry(GenericStorageEntry.newBuilder() |
| .addAllValue(Collections.<ByteString>emptyList())) |
| .build()); |
| replayAll(); |
| |
| assertTrue(executor.readAllFromStorage(StorageType.EMOTICON_HISTORY).isEmpty()); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testReload() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| |
| executor.evaluateAsynchronously( |
| matchesBuilder(Input.newBuilder() |
| .setType(CommandType.RELOAD)), |
| same(Optional.<KeyEventInterface>absent()), same(Optional.<EvaluationCallback>absent())); |
| replayAll(); |
| |
| executor.reload(); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testSendUserDictionaryCommand() { |
| SessionExecutor executor = createSessionExecutorMock(); |
| |
| UserDictionaryCommand command = UserDictionaryCommand.newBuilder() |
| .setType(UserDictionaryCommand.CommandType.NO_OPERATION) |
| .build(); |
| |
| expect(executor.evaluateSynchronously( |
| Input.newBuilder() |
| .setType(CommandType.SEND_USER_DICTIONARY_COMMAND) |
| .setUserDictionaryCommand(command) |
| .build())) |
| .andReturn(Output.getDefaultInstance()); |
| replayAll(); |
| |
| assertEquals(UserDictionaryCommandStatus.getDefaultInstance(), |
| executor.sendUserDictionaryCommand(command)); |
| |
| verifyAll(); |
| } |
| |
| @LargeTest |
| @StressTest |
| public void testStressConversion() throws InterruptedException { |
| MemoryLogger memoryLogger = new MemoryLogger("testStressConversion", 100); |
| |
| SessionExecutor session = SessionExecutor.getInstance(getInstrumentation().getContext()); |
| Context context = getInstrumentation().getTargetContext(); |
| session.reset(new SessionHandlerFactory(context), context); |
| |
| int actions = 1200; |
| char minHiragana = 0x3041; |
| char maxHiragana = 0x3096; |
| int compositionLength = 20; |
| Random random = new Random(0); // Make the result deterministic. |
| StringBuilder composition = new StringBuilder(); |
| memoryLogger.logMemory("start"); |
| for (int i = 0; i < actions; ++i) { |
| composition.setLength(0); |
| for (int j = 0; j < compositionLength; ++j) { |
| composition.append((char) (random.nextInt(maxHiragana - minHiragana + 1) + minHiragana)); |
| } |
| session.sendKey(ProtoCommands.KeyEvent.newBuilder() |
| .setKeyString(composition.toString()).build(), |
| createNiceMock(KeyEventInterface.class), Collections.<TouchEvent>emptyList(), |
| createNiceMock(EvaluationCallback.class)); |
| session.sendKey(ProtoCommands.KeyEvent.newBuilder() |
| .setSpecialKey(SpecialKey.SPACE).build(), |
| createNiceMock(KeyEventInterface.class), Collections.<TouchEvent>emptyList(), |
| createNiceMock(EvaluationCallback.class)); |
| final CountDownLatch latch = new CountDownLatch(1); |
| session.submit(new EvaluationCallback() { |
| @Override |
| public void onCompleted( |
| Optional<Command> command, Optional<KeyEventInterface> triggeringKeyEvent) { |
| latch.countDown(); |
| } |
| }); |
| latch.await(); |
| session.deleteSession(); |
| memoryLogger.logMemoryInterval(); |
| } |
| memoryLogger.logMemory("end"); |
| |
| Thread.sleep(30 * 1000); |
| memoryLogger.logMemory("waited"); |
| } |
| |
| @LargeTest |
| @StressTest |
| public void testStressConversionKao() throws InterruptedException { |
| MemoryLogger memoryLogger = new MemoryLogger("testStressConversionKao", 10); |
| |
| SessionExecutor session = SessionExecutor.getInstance(getInstrumentation().getContext()); |
| Context context = getInstrumentation().getTargetContext(); |
| session.reset(new SessionHandlerFactory(context), context); |
| |
| String composition = Strings.repeat("かお、", 100); |
| memoryLogger.logMemory("start"); |
| session.sendKey(ProtoCommands.KeyEvent.newBuilder() |
| .setKeyString(composition.toString()).build(), |
| createNiceMock(KeyEventInterface.class), Collections.<TouchEvent>emptyList(), |
| createNiceMock(EvaluationCallback.class)); |
| session.sendKey(ProtoCommands.KeyEvent.newBuilder() |
| .setSpecialKey(SpecialKey.SPACE).build(), |
| createNiceMock(KeyEventInterface.class), Collections.<TouchEvent>emptyList(), |
| createNiceMock(EvaluationCallback.class)); |
| final CountDownLatch latch = new CountDownLatch(1); |
| session.submit(new EvaluationCallback() { |
| @Override |
| public void onCompleted( |
| Optional<Command> command, Optional<KeyEventInterface> triggeringKeyEvent) { |
| latch.countDown(); |
| } |
| }); |
| latch.await(); |
| memoryLogger.logMemory("beforedelete"); |
| session.deleteSession(); |
| memoryLogger.logMemory("end"); |
| |
| Thread.sleep(60 * 1000); |
| memoryLogger.logMemory("waited"); |
| } |
| } |
