Home | History | Annotate | Download | only in targetprep
      1 /*
      2  * Copyright (C) 2018 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 
     17 package com.android.tradefed.targetprep;
     18 
     19 import static org.junit.Assert.assertEquals;
     20 import static org.junit.Assert.fail;
     21 
     22 import com.android.compatibility.common.tradefed.build.CompatibilityBuildHelper;
     23 import com.android.tradefed.build.IBuildInfo;
     24 import com.android.tradefed.config.OptionSetter;
     25 import com.android.tradefed.device.ITestDevice;
     26 import com.android.tradefed.util.FileUtil;
     27 import com.android.tradefed.targetprep.TargetSetupError;
     28 
     29 import junit.framework.AssertionFailedError;
     30 
     31 import org.easymock.EasyMock;
     32 import org.junit.After;
     33 import org.junit.Before;
     34 import org.junit.Test;
     35 import org.junit.runner.RunWith;
     36 import org.junit.runners.JUnit4;
     37 
     38 import java.io.File;
     39 import java.io.FileNotFoundException;
     40 import java.util.NoSuchElementException;
     41 
     42 /**
     43  * Unit tests for {@link VtsTraceCollectPreparer}.
     44  */
     45 @RunWith(JUnit4.class)
     46 public final class VtsTraceCollectPreparerTest {
     47     private String SELINUX_PERMISSIVE = VtsTraceCollectPreparer.SELINUX_PERMISSIVE;
     48     private String VTS_LIB_DIR_32 = VtsTraceCollectPreparer.VTS_LIB_DIR_32;
     49     private String VTS_LIB_DIR_64 = VtsTraceCollectPreparer.VTS_LIB_DIR_64;
     50     private String VTS_BINARY_DIR = VtsTraceCollectPreparer.VTS_BINARY_DIR;
     51     private String VTS_TMP_LIB_DIR_32 = VtsTraceCollectPreparer.VTS_TMP_LIB_DIR_32;
     52     private String VTS_TMP_LIB_DIR_64 = VtsTraceCollectPreparer.VTS_TMP_LIB_DIR_64;
     53     private String VTS_TMP_DIR = VtsTraceCollectPreparer.VTS_TMP_DIR;
     54     private String PROFILING_CONFIGURE_BINARY = VtsTraceCollectPreparer.PROFILING_CONFIGURE_BINARY;
     55     private String TRACE_PATH = VtsTraceCollectPreparer.TRACE_PATH;
     56     private String LOCAL_TRACE_DIR = VtsTraceCollectPreparer.LOCAL_TRACE_DIR;
     57 
     58     private static final String TEST_VTS_PROFILER = "test-vts.profiler.so";
     59     private static final String TEST_VTS_LIB = "libvts-for-test.so";
     60     private static final String UNRELATED_LIB = "somelib.so";
     61 
     62     private VtsTraceCollectPreparer mPreparer;
     63     private IBuildInfo mMockBuildInfo;
     64     private ITestDevice mMockDevice;
     65     private CompatibilityBuildHelper mMockHelper;
     66     private File mTestDir;
     67 
     68     @Before
     69     public void setUp() throws Exception {
     70         mMockDevice = EasyMock.createNiceMock(ITestDevice.class);
     71         mMockBuildInfo = EasyMock.createNiceMock(IBuildInfo.class);
     72         mTestDir = FileUtil.createTempDir("vts-trace-collect-unit-tests");
     73         mMockHelper = new CompatibilityBuildHelper(mMockBuildInfo) {
     74             @Override
     75             public File getTestsDir() throws FileNotFoundException {
     76                 return mTestDir;
     77             }
     78             public File getResultDir() throws FileNotFoundException {
     79                 return mTestDir;
     80             }
     81         };
     82         mPreparer = new VtsTraceCollectPreparer() {
     83             @Override
     84             CompatibilityBuildHelper createBuildHelper(IBuildInfo buildInfo) {
     85                 return mMockHelper;
     86             }
     87         };
     88     }
     89 
     90     @After
     91     public void tearDown() throws Exception {
     92         // Cleanup test files.
     93         FileUtil.recursiveDelete(mTestDir);
     94     }
     95 
     96     @Test
     97     public void testOnSetUp() throws Exception {
     98         // Create the base dirs
     99         new File(mTestDir, VTS_LIB_DIR_32).mkdirs();
    100         new File(mTestDir, VTS_LIB_DIR_64).mkdirs();
    101         // Files that should be pushed.
    102         File testProfilerlib32 = createTestFile(TEST_VTS_PROFILER, "32");
    103         File testProfilerlib64 = createTestFile(TEST_VTS_PROFILER, "64");
    104         File testVtslib32 = createTestFile(TEST_VTS_LIB, "32");
    105         File testVtslib64 = createTestFile(TEST_VTS_LIB, "64");
    106         // Files that should not be pushed.
    107         File testUnrelatedlib32 = createTestFile(UNRELATED_LIB, "32");
    108         File testUnrelatedlib64 = createTestFile(UNRELATED_LIB, "64");
    109 
    110         EasyMock.expect(mMockDevice.pushFile(EasyMock.eq(testProfilerlib32),
    111                                 EasyMock.eq(VTS_TMP_LIB_DIR_32 + TEST_VTS_PROFILER)))
    112                 .andReturn(true)
    113                 .times(1);
    114         EasyMock.expect(mMockDevice.pushFile(EasyMock.eq(testProfilerlib64),
    115                                 EasyMock.eq(VTS_TMP_LIB_DIR_64 + TEST_VTS_PROFILER)))
    116                 .andReturn(true)
    117                 .times(1);
    118         EasyMock.expect(mMockDevice.pushFile(EasyMock.eq(testVtslib32),
    119                                 EasyMock.eq(VTS_TMP_LIB_DIR_32 + TEST_VTS_LIB)))
    120                 .andReturn(true)
    121                 .times(1);
    122         EasyMock.expect(mMockDevice.pushFile(EasyMock.eq(testVtslib64),
    123                                 EasyMock.eq(VTS_TMP_LIB_DIR_64 + TEST_VTS_LIB)))
    124                 .andReturn(true)
    125                 .times(1);
    126         EasyMock.expect(mMockDevice.pushFile(EasyMock.eq(testUnrelatedlib32),
    127                                 EasyMock.eq(VTS_TMP_LIB_DIR_32 + UNRELATED_LIB)))
    128                 .andThrow(new AssertionFailedError())
    129                 .anyTimes();
    130         EasyMock.expect(mMockDevice.pushFile(EasyMock.eq(testUnrelatedlib64),
    131                                 EasyMock.eq(VTS_TMP_LIB_DIR_64 + UNRELATED_LIB)))
    132                 .andThrow(new AssertionFailedError())
    133                 .anyTimes();
    134         EasyMock.expect(mMockDevice.pushFile(EasyMock.eq(new File(mTestDir,
    135                                                      VTS_BINARY_DIR + PROFILING_CONFIGURE_BINARY)),
    136                                 EasyMock.eq(VTS_TMP_DIR + PROFILING_CONFIGURE_BINARY)))
    137                 .andReturn(true)
    138                 .times(1);
    139         EasyMock.expect(mMockDevice.executeShellCommand(EasyMock.eq("getenforce")))
    140                 .andReturn("")
    141                 .times(1);
    142         EasyMock.expect(mMockDevice.executeShellCommand(
    143                                 EasyMock.eq("setenforce " + SELINUX_PERMISSIVE)))
    144                 .andReturn("")
    145                 .times(1);
    146 
    147         // Configure the trace directory path.
    148         File traceDir = new File(mTestDir, LOCAL_TRACE_DIR);
    149         mMockBuildInfo.addBuildAttribute(TRACE_PATH, traceDir.getAbsolutePath());
    150         EasyMock.expectLastCall().times(1);
    151         EasyMock.replay(mMockDevice, mMockBuildInfo);
    152 
    153         // Run setUp.
    154         mPreparer.setUp(mMockDevice, mMockBuildInfo);
    155         EasyMock.verify(mMockDevice, mMockBuildInfo);
    156     }
    157 
    158     @Test
    159     public void testOnSetUpPushFileException() throws Exception {
    160         EasyMock.expect(mMockDevice.pushFile(EasyMock.anyObject(), EasyMock.anyObject()))
    161                 .andThrow(new NoSuchElementException("file not found."));
    162         EasyMock.replay(mMockDevice);
    163         try {
    164             mPreparer.setUp(mMockDevice, mMockBuildInfo);
    165             EasyMock.verify(mMockDevice);
    166         } catch (TargetSetupError e) {
    167             // Expected.
    168             assertEquals("Could not push profiler.", e.getMessage());
    169             return;
    170         }
    171         fail();
    172     }
    173 
    174     @Test
    175     public void testOnTearDown() throws Exception {
    176         EasyMock.expect(mMockDevice.executeShellCommand(EasyMock.eq("getenforce")))
    177                 .andReturn(SELINUX_PERMISSIVE);
    178         EasyMock.expect(mMockDevice.executeShellCommand(
    179                                 EasyMock.eq("setenforce " + SELINUX_PERMISSIVE)))
    180                 .andReturn("")
    181                 .times(1);
    182         EasyMock.replay(mMockDevice, mMockBuildInfo);
    183         mPreparer.setUp(mMockDevice, mMockBuildInfo);
    184         mPreparer.tearDown(mMockDevice, mMockBuildInfo, null);
    185         EasyMock.verify(mMockDevice, mMockBuildInfo);
    186     }
    187 
    188     /**
    189      * Helper method to create a test file under mTestDir.
    190      *
    191      * @param fileName test file name.
    192      * @param bitness bitness for the test file. Only supports "32" or "64".
    193      * @return created test file, null for unsupported bitness.
    194      */
    195     private File createTestFile(String fileName, String bitness) throws Exception {
    196         if (bitness == "32") {
    197             File testFile32 = new File(mTestDir, VTS_LIB_DIR_32 + fileName);
    198             testFile32.createNewFile();
    199             return testFile32;
    200         } else if (bitness == "64") {
    201             File testFile64 = new File(mTestDir, VTS_LIB_DIR_64 + fileName);
    202             testFile64.createNewFile();
    203             return testFile64;
    204         }
    205         return null;
    206     }
    207 }
    208