1 /* 2 * Copyright (C) 2010 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 package com.android.cts.tradefed.testtype; 17 18 import com.android.cts.tradefed.build.StubCtsBuildHelper; 19 import com.android.cts.tradefed.result.PlanCreator; 20 import com.android.ddmlib.testrunner.TestIdentifier; 21 import com.android.tradefed.device.DeviceNotAvailableException; 22 import com.android.tradefed.device.ITestDevice; 23 import com.android.tradefed.result.ITestInvocationListener; 24 import com.android.tradefed.testtype.IRemoteTest; 25 import com.android.tradefed.util.xml.AbstractXmlParser.ParseException; 26 27 import junit.framework.TestCase; 28 29 import org.easymock.EasyMock; 30 31 import java.io.ByteArrayInputStream; 32 import java.io.File; 33 import java.io.FileNotFoundException; 34 import java.io.InputStream; 35 import java.util.ArrayList; 36 import java.util.Collection; 37 38 /** 39 * Unit tests for {@link CtsTest}. 40 */ 41 public class CtsTestTest extends TestCase { 42 43 private static final String PACKAGE_NAME = "test-uri"; 44 /** the test fixture under test, with all external dependencies mocked out */ 45 private CtsTest mCtsTest; 46 private ITestPackageRepo mMockRepo; 47 private ITestPlan mMockPlan; 48 private ITestDevice mMockDevice; 49 private ITestInvocationListener mMockListener; 50 private StubCtsBuildHelper mStubBuildHelper; 51 private ITestPackageDef mMockPackageDef; 52 private IRemoteTest mMockTest; 53 54 private static final String PLAN_NAME = "CTS"; 55 56 /** 57 * {@inheritDoc} 58 */ 59 @Override 60 protected void setUp() throws Exception { 61 super.setUp(); 62 mMockRepo = EasyMock.createMock(ITestPackageRepo.class); 63 mMockPlan = EasyMock.createMock(ITestPlan.class); 64 mMockDevice = EasyMock.createMock(ITestDevice.class); 65 mMockListener = EasyMock.createNiceMock(ITestInvocationListener.class); 66 mStubBuildHelper = new StubCtsBuildHelper(); 67 mMockPackageDef = EasyMock.createMock(ITestPackageDef.class); 68 mMockTest = EasyMock.createMock(IRemoteTest.class); 69 70 mCtsTest = new CtsTest() { 71 @Override 72 ITestPackageRepo createTestCaseRepo() { 73 return mMockRepo; 74 } 75 76 @Override 77 ITestPlan createPlan(String planName) { 78 return mMockPlan; 79 } 80 81 @Override 82 ITestPlan createPlan(PlanCreator planCreator) { 83 return mMockPlan; 84 } 85 86 @Override 87 InputStream createXmlStream(File xmlFile) throws FileNotFoundException { 88 // return empty stream, not used 89 return new ByteArrayInputStream(new byte[0]); 90 } 91 }; 92 mCtsTest.setDevice(mMockDevice); 93 mCtsTest.setBuildHelper(mStubBuildHelper); 94 // turn off device collection for simplicity 95 mCtsTest.setSkipDeviceInfo(true); 96 EasyMock.expect(mMockPackageDef.getTargetApkName()).andStubReturn(null); 97 EasyMock.expect(mMockPackageDef.getTargetPackageName()).andStubReturn(null); 98 } 99 100 /** 101 * Test normal case {@link CtsTest#run(java.util.List)} when running a plan. 102 */ 103 @SuppressWarnings("unchecked") 104 public void testRun_plan() throws DeviceNotAvailableException, ParseException { 105 setParsePlanExceptations(); 106 107 setCreateAndRunTestExpectations(); 108 109 replayMocks(); 110 mCtsTest.run(mMockListener); 111 verifyMocks(); 112 } 113 114 /** 115 * Test normal case {@link CtsTest#run(java.util.List)} when running a package. 116 */ 117 @SuppressWarnings("unchecked") 118 public void testRun_package() throws DeviceNotAvailableException { 119 mCtsTest.addPackageName(PACKAGE_NAME); 120 121 setCreateAndRunTestExpectations(); 122 123 replayMocks(); 124 mCtsTest.run(mMockListener); 125 verifyMocks(); 126 } 127 128 /** 129 * Test a resumed run 130 */ 131 @SuppressWarnings("unchecked") 132 public void testRun_resume() throws DeviceNotAvailableException { 133 mCtsTest.addPackageName(PACKAGE_NAME); 134 135 setCreateAndRunTestExpectations(); 136 // abort the first run 137 EasyMock.expectLastCall().andThrow(new DeviceNotAvailableException()); 138 139 // now expect test to be resumed 140 mMockTest.run((ITestInvocationListener)EasyMock.anyObject()); 141 EasyMock.expect(mMockPackageDef.getName()).andReturn(PACKAGE_NAME); 142 EasyMock.expect(mMockPackageDef.getDigest()).andReturn("digest"); 143 144 replayMocks(); 145 try { 146 mCtsTest.run(mMockListener); 147 fail("Did not throw DeviceNotAvailableException"); 148 } catch (DeviceNotAvailableException e) { 149 // expected 150 } 151 // now resume, and expect same test's run method to be called again 152 mCtsTest.run(mMockListener); 153 verifyMocks(); 154 } 155 156 /** 157 * Test normal case {@link CtsTest#run(java.util.List)} when running a class. 158 */ 159 @SuppressWarnings("unchecked") 160 public void testRun_class() throws DeviceNotAvailableException { 161 final String className = "className"; 162 final String methodName = "methodName"; 163 mCtsTest.setClassName(className); 164 mCtsTest.setMethodName(methodName); 165 166 EasyMock.expect(mMockRepo.findPackageForTest(className)).andReturn(PACKAGE_NAME); 167 mMockPackageDef.setClassName(className, methodName); 168 169 setCreateAndRunTestExpectations(); 170 171 replayMocks(); 172 mCtsTest.run(mMockListener); 173 verifyMocks(); 174 } 175 176 /** 177 * Test {@link CtsTest#run(java.util.List)} when --excluded-package is specified 178 */ 179 public void testRun_excludedPackage() throws DeviceNotAvailableException, ParseException { 180 mCtsTest.setPlanName(PLAN_NAME); 181 mMockPlan.parse((InputStream)EasyMock.anyObject()); 182 Collection<String> uris = new ArrayList<String>(1); 183 uris.add(PACKAGE_NAME); 184 EasyMock.expect(mMockPlan.getTestUris()).andReturn(uris); 185 186 mCtsTest.addExcludedPackageName(PACKAGE_NAME); 187 188 // PACKAGE_NAME would normally be run, but it has been excluded. Expect nothing to happen 189 replayMocks(); 190 mCtsTest.run(mMockListener); 191 verifyMocks(); 192 } 193 194 /** 195 * Test {@link CtsTest#run(ITestInvocationListener))} when --continue-session is specified 196 */ 197 public void testRun_continueSession() throws DeviceNotAvailableException, ParseException { 198 mCtsTest.setContinueSessionId(1); 199 Collection<String> uris = new ArrayList<String>(1); 200 uris.add(PACKAGE_NAME); 201 EasyMock.expect(mMockPlan.getTestUris()).andReturn(uris); 202 TestFilter filter = new TestFilter(); 203 EasyMock.expect(mMockPlan.getExcludedTestFilter(PACKAGE_NAME)).andReturn( 204 filter); 205 mMockPackageDef.setExcludedTestFilter(filter); 206 207 setCreateAndRunTestExpectations(); 208 209 replayMocks(); 210 mCtsTest.run(mMockListener); 211 verifyMocks(); 212 } 213 214 /** 215 * Set EasyMock expectations for parsing {@link #PLAN_NAME} 216 */ 217 private void setParsePlanExceptations() throws ParseException { 218 mCtsTest.setPlanName(PLAN_NAME); 219 mMockPlan.parse((InputStream)EasyMock.anyObject()); 220 Collection<String> uris = new ArrayList<String>(1); 221 uris.add(PACKAGE_NAME); 222 EasyMock.expect(mMockPlan.getTestUris()).andReturn(uris); 223 TestFilter filter = new TestFilter(); 224 EasyMock.expect(mMockPlan.getExcludedTestFilter(PACKAGE_NAME)).andReturn( 225 filter); 226 mMockPackageDef.setExcludedTestFilter(filter); 227 } 228 229 /** 230 * Set EasyMock expectations for creating and running a package with PACKAGE_NAME 231 */ 232 private void setCreateAndRunTestExpectations() throws DeviceNotAvailableException { 233 EasyMock.expect(mMockRepo.getTestPackage(PACKAGE_NAME)).andReturn(mMockPackageDef); 234 EasyMock.expect(mMockPackageDef.createTest((File)EasyMock.anyObject())).andReturn( 235 mMockTest); 236 EasyMock.expect(mMockPackageDef.getTests()).andReturn(new ArrayList<TestIdentifier>()); 237 EasyMock.expect(mMockPackageDef.getUri()).andStubReturn(PACKAGE_NAME); 238 EasyMock.expect(mMockPackageDef.getName()).andReturn(PACKAGE_NAME); 239 EasyMock.expect(mMockPackageDef.getDigest()).andReturn("digest"); 240 241 mMockTest.run((ITestInvocationListener)EasyMock.anyObject()); 242 } 243 244 /** 245 * Test {@link CtsTest#run(java.util.List)} when --plan and --package options have not been 246 * specified 247 */ 248 public void testRun_nothingToRun() throws DeviceNotAvailableException { 249 try { 250 mCtsTest.run(mMockListener); 251 fail("IllegalArgumentException not thrown"); 252 } catch (IllegalArgumentException e) { 253 // expected 254 } 255 } 256 257 /** 258 * Test {@link CtsTest#run(ITestInvocationListener))} when --plan and --package options have 259 * been specified. 260 */ 261 public void testRun_packagePlan() throws DeviceNotAvailableException { 262 mCtsTest.setPlanName(PLAN_NAME); 263 mCtsTest.addPackageName(PACKAGE_NAME); 264 try { 265 mCtsTest.run(mMockListener); 266 fail("IllegalArgumentException not thrown"); 267 } catch (IllegalArgumentException e) { 268 // expected 269 } 270 } 271 272 /** 273 * Test {@link CtsTest#run(java.util.List)} when --plan and --class options have been 274 * specified 275 */ 276 public void testRun_planClass() throws DeviceNotAvailableException { 277 mCtsTest.setPlanName(PLAN_NAME); 278 mCtsTest.setClassName("class"); 279 try { 280 mCtsTest.run(mMockListener); 281 fail("IllegalArgumentException not thrown"); 282 } catch (IllegalArgumentException e) { 283 // expected 284 } 285 } 286 287 /** 288 * Test {@link CtsTest#run(java.util.List)} when --package and --class options have been 289 * specified 290 */ 291 public void testRun_packageClass() throws DeviceNotAvailableException { 292 mCtsTest.addPackageName(PACKAGE_NAME); 293 mCtsTest.setClassName("class"); 294 try { 295 mCtsTest.run(mMockListener); 296 fail("IllegalArgumentException not thrown"); 297 } catch (IllegalArgumentException e) { 298 // expected 299 } 300 } 301 302 /** 303 * Test {@link CtsTest#run(java.util.List)} when --plan, --package and --class options have been 304 * specified 305 */ 306 public void testRun_planPackageClass() throws DeviceNotAvailableException { 307 mCtsTest.setPlanName(PLAN_NAME); 308 mCtsTest.addPackageName(PACKAGE_NAME); 309 mCtsTest.setClassName("class"); 310 try { 311 mCtsTest.run(mMockListener); 312 fail("IllegalArgumentException not thrown"); 313 } catch (IllegalArgumentException e) { 314 // expected 315 } 316 } 317 318 /** 319 * Test {@link CtsTest#run(java.util.List)} when --plan, --continue-option options have been 320 * specified 321 */ 322 public void testRun_planContinue() throws DeviceNotAvailableException { 323 mCtsTest.setPlanName(PLAN_NAME); 324 mCtsTest.setContinueSessionId(1); 325 try { 326 mCtsTest.run(mMockListener); 327 fail("IllegalArgumentException not thrown"); 328 } catch (IllegalArgumentException e) { 329 // expected 330 } 331 } 332 333 private void replayMocks(Object... mocks) { 334 EasyMock.replay(mMockRepo, mMockPlan, mMockDevice, mMockListener, mMockPackageDef, 335 mMockTest); 336 EasyMock.replay(mocks); 337 } 338 339 private void verifyMocks(Object... mocks) { 340 EasyMock.verify(mMockRepo, mMockPlan, mMockDevice, mMockListener, mMockPackageDef, 341 mMockTest); 342 EasyMock.verify(mocks); 343 } 344 } 345
