aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--tests/AndroidManifest.xml2
-rw-r--r--tests/src/org/cyanogenmod/tests/weather/unit/CMWeatherManagerTest.java243
-rw-r--r--tests/src/org/cyanogenmod/tests/weather/unit/MockWeatherProviderService.java54
-rw-r--r--tests/src/org/cyanogenmod/tests/weather/unit/WeatherProviderServiceTest.java302
4 files changed, 600 insertions, 1 deletions
diff --git a/tests/AndroidManifest.xml b/tests/AndroidManifest.xml
index 4a91aa9..3560431 100644
--- a/tests/AndroidManifest.xml
+++ b/tests/AndroidManifest.xml
@@ -28,7 +28,7 @@
<uses-permission android:name="cyanogenmod.permission.ACCESS_THEME_MANAGER" />
<uses-permission android:name="cyanogenmod.permission.MANAGE_LIVEDISPLAY" />
<uses-permission android:name="cyanogenmod.permission.OBSERVE_AUDIO_SESSIONS" />
-
+ <uses-permission android:name="cyanogenmod.permission.ACCESS_WEATHER_MANAGER" />
<uses-permission android:name="android.permission.STATUS_BAR_SERVICE" />
<application android:name=".CyanogenModTestApplication"
diff --git a/tests/src/org/cyanogenmod/tests/weather/unit/CMWeatherManagerTest.java b/tests/src/org/cyanogenmod/tests/weather/unit/CMWeatherManagerTest.java
new file mode 100644
index 0000000..c382d3f
--- /dev/null
+++ b/tests/src/org/cyanogenmod/tests/weather/unit/CMWeatherManagerTest.java
@@ -0,0 +1,243 @@
+/**
+ * Copyright (C) 2016 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.cyanogenmod.tests.weather.unit;
+
+import android.location.Location;
+import android.test.AndroidTestCase;
+import android.test.suitebuilder.annotation.MediumTest;
+import android.test.suitebuilder.annotation.SmallTest;
+import cyanogenmod.weather.CMWeatherManager;
+import cyanogenmod.weather.CMWeatherManager.LookupCityRequestListener;
+import cyanogenmod.weather.CMWeatherManager.WeatherServiceProviderChangeListener;
+import cyanogenmod.weather.CMWeatherManager.WeatherUpdateRequestListener;
+import cyanogenmod.weather.ICMWeatherManager;
+import cyanogenmod.weather.RequestInfo;
+import cyanogenmod.weather.WeatherInfo;
+import cyanogenmod.weather.WeatherLocation;
+import org.cyanogenmod.tests.common.MockIBinderStubForInterface;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+public class CMWeatherManagerTest extends AndroidTestCase {
+
+ private CMWeatherManager mWeatherManager;
+ private static final String CITY_NAME = "Seattle, WA";
+ private static final int COUNTDOWN = 1;
+ private static final int REQUEST_ID = 42;
+ private static final String MOCKED_WEATHER_PROVIDER_LABEL = "Mock'd Weather Service";
+ private ICMWeatherManager.Stub mICMWeatherManagerSpy;
+ private static final String DESCRIPTOR = "cyanogenmod.weather.ICMWeatherManager";
+
+ @Override
+ protected void setUp() throws Exception {
+ super.setUp();
+ setUpMockICMWeatherManager();
+ }
+
+ private void setUpMockICMWeatherManager() {
+ mWeatherManager = CMWeatherManager.getInstance(getContext());
+ Field f;
+ try {
+ f = mWeatherManager.getClass().getDeclaredField("sWeatherManagerService");
+ f.setAccessible(true);
+
+ mICMWeatherManagerSpy
+ = MockIBinderStubForInterface.getMockInterface(ICMWeatherManager.Stub.class);
+ f.set(mWeatherManager, mICMWeatherManagerSpy);
+
+ Mockito.doAnswer(new WeatherUpdateRequestAnswer())
+ .when(mICMWeatherManagerSpy).updateWeather(Mockito.any(RequestInfo.class));
+
+ Mockito.doAnswer(new LookUpCityAnswer())
+ .when(mICMWeatherManagerSpy).lookupCity(Mockito.any(RequestInfo.class));
+
+ Mockito.doAnswer(new GetActiveWeatherServiceProviderLabelAnser())
+ .when(mICMWeatherManagerSpy).getActiveWeatherServiceProviderLabel();
+
+ Mockito.doAnswer(new CancelRequestAnswer())
+ .when(mICMWeatherManagerSpy).cancelRequest(Mockito.eq(REQUEST_ID));
+ } catch (Exception e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ private static class WeatherUpdateRequestAnswer implements Answer<Integer> {
+
+ @Override
+ public Integer answer(InvocationOnMock invocation) throws Throwable {
+ final RequestInfo requestInfo = (RequestInfo) invocation.getArguments()[0];
+ if (requestInfo.getRequestType() == RequestInfo.TYPE_WEATHER_BY_GEO_LOCATION_REQ) {
+ assertNotNull(requestInfo.getLocation());
+ } else {
+ assertNotNull(requestInfo.getWeatherLocation());
+ }
+ final WeatherInfo weatherInfo = new WeatherInfo.Builder(CITY_NAME,
+ 30d, requestInfo.getTemperatureUnit()).build();
+ requestInfo.getRequestListener().onWeatherRequestCompleted(requestInfo,
+ CMWeatherManager.RequestStatus.COMPLETED, weatherInfo);
+ return REQUEST_ID;
+ }
+ }
+
+ private static class LookUpCityAnswer implements Answer<Integer> {
+
+ @Override
+ public Integer answer(InvocationOnMock invocation) throws Throwable {
+ final RequestInfo requestInfo = (RequestInfo) invocation.getArguments()[0];
+ final List<WeatherLocation> locations = new ArrayList<>();
+ final String cityName = requestInfo.getCityName();
+ assertNotNull(cityName);
+ locations.add(new WeatherLocation.Builder(cityName).build());
+ requestInfo.getRequestListener().onLookupCityRequestCompleted(requestInfo,
+ CMWeatherManager.RequestStatus.COMPLETED, locations);
+ return REQUEST_ID;
+ }
+ }
+
+ private static class GetActiveWeatherServiceProviderLabelAnser implements Answer<String> {
+
+ @Override
+ public String answer(InvocationOnMock invocation) throws Throwable {
+ return MOCKED_WEATHER_PROVIDER_LABEL;
+ }
+ }
+
+ private static class CancelRequestAnswer implements Answer<Void> {
+
+ @Override
+ public Void answer(InvocationOnMock invocation) throws Throwable {
+ final int requestId = (Integer) invocation.getArguments()[0];
+ assertEquals(requestId, REQUEST_ID);
+ return null;
+ }
+ }
+
+ @SmallTest
+ public void testGetActiveWeatherServiceProviderLabel() {
+ String providerLabel = mWeatherManager.getActiveWeatherServiceProviderLabel();
+ assertEquals(MOCKED_WEATHER_PROVIDER_LABEL, providerLabel);
+ }
+
+ @MediumTest
+ public void testLookupCity() {
+ final CountDownLatch signal = new CountDownLatch(COUNTDOWN);
+ final boolean[] error = {false};
+ mWeatherManager.lookupCity(CITY_NAME,
+ new LookupCityRequestListener() {
+ @Override
+ public void onLookupCityRequestCompleted(int status,
+ List<WeatherLocation> locations) {
+ final int totalLocations = locations != null ? locations.size() : 0;
+ if (status != CMWeatherManager.RequestStatus.COMPLETED
+ || totalLocations < 1) {
+ error[0] = true;
+ }
+ signal.countDown();
+ }
+ });
+ try {
+ signal.await();
+ assertFalse(error[0]);
+ } catch (InterruptedException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @SmallTest
+ public void testRegisterListener() {
+ mWeatherManager.registerWeatherServiceProviderChangeListener(mListener);
+
+ try {
+ mWeatherManager.registerWeatherServiceProviderChangeListener(mListener);
+ throw new AssertionError("Listener was registered twice!");
+ } catch (IllegalArgumentException e) {
+ //EXPECTED
+ }
+
+ mWeatherManager.unregisterWeatherServiceProviderChangeListener(mListener);
+
+ try {
+ mWeatherManager.unregisterWeatherServiceProviderChangeListener(mListener);
+ throw new AssertionError("Listener was de-registered twice!");
+ } catch (IllegalArgumentException e) {
+ //EXPECTED
+ }
+ }
+
+ private WeatherServiceProviderChangeListener mListener
+ = new WeatherServiceProviderChangeListener() {
+ @Override
+ public void onWeatherServiceProviderChanged(String providerLabel) {}
+ };
+
+ @MediumTest
+ public void testRequestWeatherUpdateByWeatherLocation() {
+ final CountDownLatch signal = new CountDownLatch(COUNTDOWN);
+ final WeatherLocation weatherLocation = new WeatherLocation.Builder(CITY_NAME).build();
+ final boolean[] error = {false};
+ mWeatherManager.requestWeatherUpdate(weatherLocation, new WeatherUpdateRequestListener() {
+ @Override
+ public void onWeatherRequestCompleted(int status, WeatherInfo weatherInfo) {
+ if (status != CMWeatherManager.RequestStatus.COMPLETED
+ || !weatherInfo.getCity().equals(CITY_NAME)) {
+ error[0] = true;
+ }
+ signal.countDown();
+ }
+ });
+ try {
+ signal.await();
+ assertFalse(error[0]);
+ } catch (InterruptedException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @MediumTest
+ public void testRequestWeatherUpdateByLocation() {
+ final CountDownLatch signal = new CountDownLatch(COUNTDOWN);
+ final Location location = new Location("test_location_provider");
+ final boolean[] error = {false};
+ mWeatherManager.requestWeatherUpdate(location, new WeatherUpdateRequestListener() {
+ @Override
+ public void onWeatherRequestCompleted(int status, WeatherInfo weatherInfo) {
+ if (status != CMWeatherManager.RequestStatus.COMPLETED
+ || !weatherInfo.getCity().equals(CITY_NAME)) {
+ error[0] = true;
+ }
+ signal.countDown();
+ }
+ });
+ try {
+ signal.await();
+ assertFalse(error[0]);
+ } catch (InterruptedException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @SmallTest
+ public void testCancelRequest() {
+ mWeatherManager.cancelRequest(REQUEST_ID);
+ }
+}
diff --git a/tests/src/org/cyanogenmod/tests/weather/unit/MockWeatherProviderService.java b/tests/src/org/cyanogenmod/tests/weather/unit/MockWeatherProviderService.java
new file mode 100644
index 0000000..34bcc9b
--- /dev/null
+++ b/tests/src/org/cyanogenmod/tests/weather/unit/MockWeatherProviderService.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2016 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.cyanogenmod.tests.weather.unit;
+
+import cyanogenmod.weatherservice.ServiceRequest;
+import cyanogenmod.weatherservice.WeatherProviderService;
+import org.mockito.Mockito;
+
+public class MockWeatherProviderService extends WeatherProviderService {
+
+ private MockWeatherProviderService mCallTracker;
+
+ public MockWeatherProviderService() {
+ mCallTracker = Mockito.mock(MockWeatherProviderService.class);
+ }
+
+ public MockWeatherProviderService getCallTracker() {
+ return mCallTracker;
+ }
+
+ @Override
+ protected void onConnected() {
+ mCallTracker.onConnected();
+ }
+
+ @Override
+ protected void onDisconnected() {
+ mCallTracker.onDisconnected();
+ }
+
+ @Override
+ protected void onRequestSubmitted(ServiceRequest request) {
+ mCallTracker.onRequestSubmitted(request);
+ }
+
+ @Override
+ protected void onRequestCancelled(ServiceRequest request) {
+ mCallTracker.onRequestCancelled(request);
+ }
+}
diff --git a/tests/src/org/cyanogenmod/tests/weather/unit/WeatherProviderServiceTest.java b/tests/src/org/cyanogenmod/tests/weather/unit/WeatherProviderServiceTest.java
new file mode 100644
index 0000000..958dce4
--- /dev/null
+++ b/tests/src/org/cyanogenmod/tests/weather/unit/WeatherProviderServiceTest.java
@@ -0,0 +1,302 @@
+/*
+ * Copyright (C) 2016 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.cyanogenmod.tests.weather.unit;
+
+import android.location.Location;
+import android.os.IBinder;
+import cyanogenmod.weather.CMWeatherManager;
+import cyanogenmod.weather.RequestInfo;
+import cyanogenmod.weather.WeatherLocation;
+import cyanogenmod.weatherservice.IWeatherProviderService;
+import cyanogenmod.weatherservice.IWeatherProviderServiceClient;
+import cyanogenmod.weatherservice.ServiceRequest;
+import cyanogenmod.weatherservice.ServiceRequestResult;
+import org.cyanogenmod.tests.common.MockIBinderStubForInterface;
+import org.cyanogenmod.tests.common.ThreadServiceTestCase;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+
+public class WeatherProviderServiceTest extends ThreadServiceTestCase<MockWeatherProviderService> {
+
+ public WeatherProviderServiceTest() {
+ super(MockWeatherProviderService.class);
+ }
+
+ private static final String CITY_NAME = "Seattle";
+
+ public void testCityNameLookupRequest() throws Exception {
+ IBinder binder = bindService((ServiceRunnable) null);
+ assertNotNull(binder);
+
+ final IWeatherProviderService provider = IWeatherProviderService.Stub.asInterface(binder);
+ assertNotNull(provider);
+
+ provider.processCityNameLookupRequest(
+ buildMockdRequestInfo(RequestInfo.TYPE_LOOKUP_CITY_NAME_REQ));
+ runOnServiceThread(new Runnable() {
+ @Override
+ public void run() {
+ ArgumentCaptor<ServiceRequest> params
+ = ArgumentCaptor.forClass(ServiceRequest.class);
+
+ Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+ .onRequestSubmitted(params.capture());
+
+ ServiceRequest request = params.getValue();
+ assertEquals(request.getRequestInfo().getRequestType(),
+ RequestInfo.TYPE_LOOKUP_CITY_NAME_REQ);
+
+ assertEquals(request.getRequestInfo().getCityName(), CITY_NAME);
+ }
+ });
+ }
+
+ public void testWeatherUpdateRequestByWeatherLocation() throws Exception {
+ IBinder binder = bindService((ServiceRunnable) null);
+ assertNotNull(binder);
+
+ final IWeatherProviderService provider = IWeatherProviderService.Stub.asInterface(binder);
+ assertNotNull(provider);
+
+ provider.processWeatherUpdateRequest(
+ buildMockdRequestInfo(RequestInfo.TYPE_WEATHER_BY_WEATHER_LOCATION_REQ));
+ runOnServiceThread(new Runnable() {
+ @Override
+ public void run() {
+ ArgumentCaptor<ServiceRequest> params
+ = ArgumentCaptor.forClass(ServiceRequest.class);
+
+ Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+ .onRequestSubmitted(params.capture());
+
+ ServiceRequest request = params.getValue();
+ assertEquals(request.getRequestInfo().getRequestType(),
+ RequestInfo.TYPE_WEATHER_BY_WEATHER_LOCATION_REQ);
+
+ WeatherLocation weatherLocation = request.getRequestInfo().getWeatherLocation();
+ assertNotNull(weatherLocation);
+ assertEquals(weatherLocation.getCity(), CITY_NAME);
+ }
+ });
+ }
+
+ public void testWeatherUpdateRequestByGeoLocation() throws Exception {
+ IBinder binder = bindService((ServiceRunnable) null);
+ assertNotNull(binder);
+
+ final IWeatherProviderService provider = IWeatherProviderService.Stub.asInterface(binder);
+ assertNotNull(provider);
+
+ provider.processWeatherUpdateRequest(
+ buildMockdRequestInfo(RequestInfo.TYPE_WEATHER_BY_GEO_LOCATION_REQ));
+ runOnServiceThread(new Runnable() {
+ @Override
+ public void run() {
+ ArgumentCaptor<ServiceRequest> params
+ = ArgumentCaptor.forClass(ServiceRequest.class);
+
+ Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+ .onRequestSubmitted(params.capture());
+
+ ServiceRequest request = params.getValue();
+ assertEquals(request.getRequestInfo().getRequestType(),
+ RequestInfo.TYPE_WEATHER_BY_GEO_LOCATION_REQ);
+
+ Location location = request.getRequestInfo().getLocation();
+ assertNotNull(location);
+ }
+ });
+ }
+
+ public void testServiceRequestResult() throws Exception {
+ final CountDownLatch latch = new CountDownLatch(3);
+ IBinder binder = bindService((ServiceRunnable) null);
+ assertNotNull(binder);
+
+ final IWeatherProviderService provider = IWeatherProviderService.Stub.asInterface(binder);
+ assertNotNull(provider);
+
+ IWeatherProviderServiceClient client =
+ MockIBinderStubForInterface.getMockInterface(
+ IWeatherProviderServiceClient.Stub.class);
+
+ Mockito.doAnswer(new Answer() {
+ @Override
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+ RequestInfo requestInfo = (RequestInfo) invocation.getArguments()[0];
+ int result = (int) invocation.getArguments()[2];
+
+ assertNotNull(requestInfo);
+ assertEquals(result, CMWeatherManager.RequestStatus.FAILED);
+
+ latch.countDown();
+ return null;
+ }
+ }).when(client)
+ .setServiceRequestState(Mockito.any(RequestInfo.class),
+ Mockito.any(ServiceRequestResult.class),
+ Mockito.eq(CMWeatherManager.RequestStatus.FAILED));
+
+ Mockito.doAnswer(new Answer() {
+ @Override
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+
+ RequestInfo requestInfo = (RequestInfo) invocation.getArguments()[0];
+ int result = (int) invocation.getArguments()[2];
+
+ assertNotNull(requestInfo);
+ assertEquals(result, CMWeatherManager.RequestStatus.SUBMITTED_TOO_SOON);
+
+ latch.countDown();
+ return null;
+ }
+ }).when(client)
+ .setServiceRequestState(Mockito.any(RequestInfo.class),
+ Mockito.any(ServiceRequestResult.class),
+ Mockito.eq(CMWeatherManager.RequestStatus.SUBMITTED_TOO_SOON));
+
+ Mockito.doAnswer(new Answer() {
+ @Override
+ public Object answer(InvocationOnMock invocation) throws Throwable {
+ RequestInfo requestInfo = (RequestInfo) invocation.getArguments()[0];
+ ServiceRequestResult requestResult
+ = (ServiceRequestResult) invocation.getArguments()[1];
+ int result = (int) invocation.getArguments()[2];
+
+ assertNotNull(requestInfo);
+ assertNotNull(requestResult);
+ assertNotNull(requestResult.getLocationLookupList());
+ assertEquals(result, CMWeatherManager.RequestStatus.COMPLETED);
+
+ latch.countDown();
+ return null;
+ }
+ }).when(client)
+ .setServiceRequestState(Mockito.any(RequestInfo.class),
+ Mockito.any(ServiceRequestResult.class),
+ Mockito.eq(CMWeatherManager.RequestStatus.COMPLETED));
+
+ provider.setServiceClient(client);
+
+ final RequestInfo requestInfo
+ = buildMockdRequestInfo(RequestInfo.TYPE_LOOKUP_CITY_NAME_REQ);
+
+ Mockito.reset(getService().getCallTracker());
+ provider.processCityNameLookupRequest(requestInfo);
+ runOnServiceThread(new Runnable() {
+ @Override
+ public void run() {
+ ArgumentCaptor<ServiceRequest> params
+ = ArgumentCaptor.forClass(ServiceRequest.class);
+
+ Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+ .onRequestSubmitted(params.capture());
+
+ ServiceRequest request = params.getValue();
+ request.fail();
+ }
+ });
+
+ Mockito.reset(getService().getCallTracker());
+ provider.processCityNameLookupRequest(requestInfo);
+ runOnServiceThread(new Runnable() {
+ @Override
+ public void run() {
+ ArgumentCaptor<ServiceRequest> params
+ = ArgumentCaptor.forClass(ServiceRequest.class);
+
+ Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+ .onRequestSubmitted(params.capture());
+
+ ServiceRequest request = params.getValue();
+ request.reject(CMWeatherManager.RequestStatus.SUBMITTED_TOO_SOON);
+ }
+ });
+
+ Mockito.reset(getService().getCallTracker());
+ provider.processCityNameLookupRequest(requestInfo);
+ runOnServiceThread(new Runnable() {
+ @Override
+ public void run() {
+ ArgumentCaptor<ServiceRequest> params
+ = ArgumentCaptor.forClass(ServiceRequest.class);
+
+ Mockito.verify(getService().getCallTracker(), Mockito.times(1))
+ .onRequestSubmitted(params.capture());
+
+ ServiceRequest request = params.getValue();
+
+ List<WeatherLocation> locations = new ArrayList<>();
+ locations.add(new WeatherLocation.Builder(CITY_NAME).build());
+ ServiceRequestResult result = new ServiceRequestResult.Builder(locations).build();
+ request.complete(result);
+ }
+ });
+
+ try {
+ latch.await();
+ } catch (InterruptedException e) {
+ throw new AssertionError(e);
+ }
+
+ }
+
+ private RequestInfo buildMockdRequestInfo(int requestType) {
+ try {
+ Constructor<RequestInfo> c = RequestInfo.class.getDeclaredConstructor();
+ c.setAccessible(true);
+ RequestInfo info = c.newInstance();
+ Field type;
+ type = info.getClass().getDeclaredField("mRequestType");
+ type.setAccessible(true);
+ type.set(info, requestType);
+ switch (requestType) {
+ case RequestInfo.TYPE_LOOKUP_CITY_NAME_REQ:
+ Field cityName;
+ cityName = info.getClass().getDeclaredField("mCityName");
+ cityName.setAccessible(true);
+ cityName.set(info, CITY_NAME);
+ break;
+ case RequestInfo.TYPE_WEATHER_BY_WEATHER_LOCATION_REQ:
+ Field weatherLocation;
+ weatherLocation = info.getClass().getDeclaredField("mWeatherLocation");
+ weatherLocation.setAccessible(true);
+ weatherLocation.set(info, new WeatherLocation.Builder(CITY_NAME).build());
+ break;
+ case RequestInfo.TYPE_WEATHER_BY_GEO_LOCATION_REQ:
+ Field location;
+ location = info.getClass().getDeclaredField("mLocation");
+ location.setAccessible(true);
+ location.set(info, new Location("dummy_location_provider"));
+ break;
+ default:
+ throw new AssertionError("Unknown request type");
+ }
+ return info;
+ } catch (Exception e) {
+ throw new AssertionError(e);
+ }
+ }
+}