1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.speech.tts;
18
19import android.speech.tts.SynthesisCallback;
20import android.speech.tts.SynthesisRequest;
21import android.speech.tts.TextToSpeech;
22import android.test.InstrumentationTestCase;
23
24import com.android.speech.tts.MockableTextToSpeechService.IDelegate;
25import com.google.testing.littlemock.ArgumentCaptor;
26import com.google.testing.littlemock.Behaviour;
27import com.google.testing.littlemock.LittleMock;
28import junit.framework.Assert;
29
30import java.util.Locale;
31import java.util.concurrent.Callable;
32import java.util.concurrent.CountDownLatch;
33import java.util.concurrent.TimeUnit;
34
35public class TextToSpeechTests extends InstrumentationTestCase {
36    private static final String MOCK_ENGINE = "com.android.speech.tts";
37    private static final String MOCK_PACKAGE = "com.android.speech.tts.__testpackage__";
38
39    private TextToSpeech mTts;
40
41    @Override
42    public void setUp() throws Exception {
43        IDelegate passThrough = LittleMock.mock(IDelegate.class);
44        MockableTextToSpeechService.setMocker(passThrough);
45
46        blockingInitAndVerify(MOCK_ENGINE, TextToSpeech.SUCCESS);
47        assertEquals(MOCK_ENGINE, mTts.getCurrentEngine());
48    }
49
50
51    @Override
52    public void tearDown() {
53        if (mTts != null) {
54            mTts.shutdown();
55        }
56    }
57
58    public void testEngineInitialized() throws Exception {
59        // Fail on an engine that doesn't exist.
60        blockingInitAndVerify("__DOES_NOT_EXIST__", TextToSpeech.ERROR);
61
62        // Also, the "current engine" must be null
63        assertNull(mTts.getCurrentEngine());
64    }
65
66    public void testSetLanguage_delegation() {
67        IDelegate delegate = LittleMock.mock(IDelegate.class);
68        MockableTextToSpeechService.setMocker(delegate);
69
70        // Test 1 :Tests that calls to onLoadLanguage( ) are delegated through to the
71        // service without any caching or intermediate steps.
72        mTts.setLanguage(new Locale("eng", "USA", "variant"));
73        LittleMock.verify(delegate, LittleMock.times(1)).onIsLanguageAvailable(
74                "eng", "USA", "variant");
75        LittleMock.verify(delegate, LittleMock.times(1)).onLoadLanguage(
76                "eng", "USA", "variant");
77    }
78
79    public void testSetLanguage_availableLanguage() throws Exception {
80        IDelegate delegate = LittleMock.mock(IDelegate.class);
81        MockableTextToSpeechService.setMocker(delegate);
82
83        // ---------------------------------------------------------
84        // Test 2 : Tests that when the language is successfully set
85        // like above (returns LANG_COUNTRY_AVAILABLE). That the
86        // request language changes from that point on.
87        LittleMock.doReturn(TextToSpeech.LANG_COUNTRY_AVAILABLE).when(delegate).onIsLanguageAvailable(
88                "eng", "USA", "variant");
89        LittleMock.doReturn(TextToSpeech.LANG_COUNTRY_AVAILABLE).when(delegate).onLoadLanguage(
90                "eng", "USA", "variant");
91        mTts.setLanguage(new Locale("eng", "USA", "variant"));
92        blockingCallSpeak("foo bar", delegate);
93        ArgumentCaptor<SynthesisRequest> req = LittleMock.createCaptor();
94        LittleMock.verify(delegate, LittleMock.times(1)).onSynthesizeText(req.capture(),
95                LittleMock.<SynthesisCallback>anyObject());
96
97        assertEquals("eng", req.getValue().getLanguage());
98        assertEquals("USA", req.getValue().getCountry());
99        assertEquals("", req.getValue().getVariant());
100    }
101
102    public void testSetLanguage_unavailableLanguage() throws Exception {
103        IDelegate delegate = LittleMock.mock(IDelegate.class);
104        MockableTextToSpeechService.setMocker(delegate);
105
106        // ---------------------------------------------------------
107        // TEST 3 : Tests that the language that is set does not change when the
108        // engine reports it could not load the specified language.
109        LittleMock.doReturn(TextToSpeech.LANG_NOT_SUPPORTED).when(
110                delegate).onIsLanguageAvailable("fra", "FRA", "");
111        LittleMock.doReturn(TextToSpeech.LANG_NOT_SUPPORTED).when(
112                delegate).onLoadLanguage("fra", "FRA", "");
113        mTts.setLanguage(Locale.FRANCE);
114        blockingCallSpeak("le fou barre", delegate);
115        ArgumentCaptor<SynthesisRequest> req2 = LittleMock.createCaptor();
116        LittleMock.verify(delegate, LittleMock.times(1)).onSynthesizeText(req2.capture(),
117                        LittleMock.<SynthesisCallback>anyObject());
118
119        // The params are basically unchanged.
120        assertEquals("eng", req2.getValue().getLanguage());
121        assertEquals("USA", req2.getValue().getCountry());
122        assertEquals("", req2.getValue().getVariant());
123    }
124
125    public void testIsLanguageAvailable() {
126        IDelegate delegate = LittleMock.mock(IDelegate.class);
127        MockableTextToSpeechService.setMocker(delegate);
128
129        // Test1: Simple end to end test.
130        LittleMock.doReturn(TextToSpeech.LANG_COUNTRY_AVAILABLE).when(
131                delegate).onIsLanguageAvailable("eng", "USA", "");
132
133        assertEquals(TextToSpeech.LANG_COUNTRY_AVAILABLE, mTts.isLanguageAvailable(Locale.US));
134        LittleMock.verify(delegate, LittleMock.times(1)).onIsLanguageAvailable(
135                "eng", "USA", "");
136    }
137
138
139    private void blockingCallSpeak(String speech, IDelegate mock) throws
140            InterruptedException {
141        final CountDownLatch latch = new CountDownLatch(1);
142        doCountDown(latch).when(mock).onSynthesizeText(LittleMock.<SynthesisRequest>anyObject(),
143                LittleMock.<SynthesisCallback>anyObject());
144        mTts.speak(speech, TextToSpeech.QUEUE_ADD, null);
145
146        awaitCountDown(latch, 5, TimeUnit.SECONDS);
147    }
148
149    private void blockingInitAndVerify(final String engine, int errorCode) throws
150            InterruptedException {
151        TextToSpeech.OnInitListener listener = LittleMock.mock(
152                TextToSpeech.OnInitListener.class);
153
154        final CountDownLatch latch = new CountDownLatch(1);
155        doCountDown(latch).when(listener).onInit(errorCode);
156
157        mTts = new TextToSpeech(getInstrumentation().getTargetContext(),
158                listener, engine, MOCK_PACKAGE, false /* use fallback package */);
159
160        awaitCountDown(latch, 5, TimeUnit.SECONDS);
161    }
162
163    public interface CountDownBehaviour extends Behaviour {
164        /** Used to mock methods that return a result. */
165        Behaviour andReturn(Object result);
166    }
167
168    public static CountDownBehaviour doCountDown(final CountDownLatch latch) {
169        return new CountDownBehaviour() {
170            @Override
171            public <T> T when(T mock) {
172                return LittleMock.doAnswer(new Callable<Void>() {
173                    @Override
174                    public Void call() throws Exception {
175                        latch.countDown();
176                        return null;
177                    }
178                }).when(mock);
179            }
180
181            @Override
182            public Behaviour andReturn(final Object result) {
183                return new Behaviour() {
184                    @Override
185                    public <T> T when(T mock) {
186                        return LittleMock.doAnswer(new Callable<Object>() {
187                            @Override
188                            public Object call() throws Exception {
189                                latch.countDown();
190                                return result;
191                            }
192                        }).when(mock);
193                    }
194                };
195            }
196        };
197    }
198
199    public static void awaitCountDown(CountDownLatch latch, long timeout, TimeUnit unit)
200            throws InterruptedException {
201        Assert.assertTrue("Waited too long for method call", latch.await(timeout, unit));
202    }
203}
204