/*
 * Copyright (C) 2016 The Android Open Source 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 com.android.tradefed.testtype;

import com.android.tradefed.device.CollectingOutputReceiver;
import com.android.tradefed.device.DeviceNotAvailableException;
import com.android.tradefed.device.ITestDevice;
import com.android.tradefed.device.MockFileUtil;
import com.android.tradefed.invoker.TestInformation;
import com.android.tradefed.metrics.proto.MetricMeasurement.Metric;
import com.android.tradefed.result.ITestInvocationListener;
import com.android.tradefed.result.TestDescription;

import junit.framework.TestCase;

import org.easymock.EasyMock;

import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * Unit tests for {@link GoogleBenchmarkTest}.
 */
public class GoogleBenchmarkTestTest extends TestCase {

    private ITestInvocationListener mMockInvocationListener = null;
    private CollectingOutputReceiver mMockReceiver = null;
    private ITestDevice mMockITestDevice = null;
    private GoogleBenchmarkTest mGoogleBenchmarkTest;
    private TestInformation mTestInfo;
    private TestDescription mDummyTest;

    /**
     * Helper to initialize the various EasyMocks we'll need.
     */
    @Override
    protected void setUp() throws Exception {
        super.setUp();
        mMockInvocationListener = EasyMock.createMock(ITestInvocationListener.class);
        mMockReceiver = new CollectingOutputReceiver();
        mMockITestDevice = EasyMock.createMock(ITestDevice.class);
        mDummyTest = new TestDescription("Class", "method");
        EasyMock.expect(mMockITestDevice.getSerialNumber()).andStubReturn("serial");
        mGoogleBenchmarkTest =
                new GoogleBenchmarkTest() {
                    @Override
                    CollectingOutputReceiver createOutputCollector() {
                        return mMockReceiver;
                    }

                    @Override
                    GoogleBenchmarkResultParser createResultParser(
                            String runName, ITestInvocationListener listener) {
                        return new GoogleBenchmarkResultParser(runName, listener) {
                            @Override
                            public Map<String, String> parse(CollectingOutputReceiver output) {
                                listener.testStarted(mDummyTest);
                                listener.testEnded(mDummyTest, Collections.emptyMap());
                                return Collections.emptyMap();
                            }
                        };
                    }
                };
        mGoogleBenchmarkTest.setDevice(mMockITestDevice);
        mTestInfo = TestInformation.newBuilder().build();
    }

    /**
     * Helper that replays all mocks.
     */
    private void replayMocks() {
      EasyMock.replay(mMockInvocationListener, mMockITestDevice);
    }

    /**
     * Helper that verifies all mocks.
     */
    private void verifyMocks() {
      EasyMock.verify(mMockInvocationListener, mMockITestDevice);
    }

    /**
     * Test the run method for a couple tests
     */
    public void testRun() throws DeviceNotAvailableException {
        final String nativeTestPath = GoogleBenchmarkTest.DEFAULT_TEST_PATH;
        final String test1 = "test1";
        final String test2 = "test2";
        MockFileUtil.setMockDirContents(mMockITestDevice, nativeTestPath, test1, test2);
        EasyMock.expect(mMockITestDevice.doesFileExist(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath + "/test1")).andReturn(false);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath + "/test2")).andReturn(false);
        String[] files = new String[] {"test1", "test2"};
        EasyMock.expect(mMockITestDevice.getChildren(nativeTestPath)).andReturn(files);
        EasyMock.expect(mMockITestDevice.executeShellCommand(EasyMock.contains("chmod")))
                .andReturn("").times(2);
        mMockITestDevice.executeShellCommand(EasyMock.contains(test1), EasyMock.same(mMockReceiver),
                EasyMock.anyLong(), (TimeUnit)EasyMock.anyObject(), EasyMock.anyInt());
        mMockITestDevice.executeShellCommand(EasyMock.contains(test2), EasyMock.same(mMockReceiver),
                EasyMock.anyLong(), (TimeUnit)EasyMock.anyObject(), EasyMock.anyInt());

        EasyMock.expect(
                        mMockITestDevice.executeShellCommand(
                                String.format(
                                        "%s/test1 --benchmark_list_tests=true", nativeTestPath)))
                .andReturn("method1\nmethod2\nmethod3");

        EasyMock.expect(
                        mMockITestDevice.executeShellCommand(
                                String.format(
                                        "%s/test2 --benchmark_list_tests=true", nativeTestPath)))
                .andReturn("method1\nmethod2\n");
        mMockInvocationListener.testRunStarted(test1, 3);
        mMockInvocationListener.testStarted(mDummyTest);
        mMockInvocationListener.testEnded(
                EasyMock.eq(mDummyTest), EasyMock.<HashMap<String, String>>anyObject());
        mMockInvocationListener.testRunStarted(test2, 2);
        mMockInvocationListener.testStarted(mDummyTest);
        mMockInvocationListener.testEnded(
                EasyMock.eq(mDummyTest), EasyMock.<HashMap<String, String>>anyObject());
        mMockInvocationListener.testRunEnded(
                EasyMock.anyLong(), EasyMock.<HashMap<String, Metric>>anyObject());
        EasyMock.expectLastCall().times(2);
        replayMocks();

        mGoogleBenchmarkTest.run(mTestInfo, mMockInvocationListener);
        verifyMocks();
    }

    /**
     * Test the run method when no device is set.
     */
    public void testRun_noDevice() throws DeviceNotAvailableException {
        mGoogleBenchmarkTest.setDevice(null);
        try {
            mGoogleBenchmarkTest.run(mTestInfo, mMockInvocationListener);
        } catch (IllegalArgumentException e) {
            assertEquals("Device has not been set", e.getMessage());
            return;
        }
        fail();
    }

    /**
     * Test the run method for a couple tests
     */
    public void testRun_noBenchmarkDir() throws DeviceNotAvailableException {
        EasyMock.expect(mMockITestDevice.doesFileExist(GoogleBenchmarkTest.DEFAULT_TEST_PATH))
                .andReturn(false);
        replayMocks();
        try {
            mGoogleBenchmarkTest.run(mTestInfo, mMockInvocationListener);
            fail("Should have thrown an exception.");
        } catch (RuntimeException e) {
            // expected
        }
        verifyMocks();
    }

    /**
     * Test the run method for a couple tests with a module name
     */
    public void testRun_withModuleName() throws DeviceNotAvailableException {
        final String moduleName = "module";
        final String nativeTestPath =
                String.format("%s/%s", GoogleBenchmarkTest.DEFAULT_TEST_PATH, moduleName);
        mGoogleBenchmarkTest.setModuleName(moduleName);
        final String test1 = "test1";
        final String test2 = "test2";
        MockFileUtil.setMockDirContents(mMockITestDevice, nativeTestPath, test1, test2);
        EasyMock.expect(mMockITestDevice.doesFileExist(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath + "/test1")).andReturn(false);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath + "/test2")).andReturn(false);
        String[] files = new String[] {"test1", "test2"};
        EasyMock.expect(mMockITestDevice.getChildren(nativeTestPath)).andReturn(files);
        EasyMock.expect(mMockITestDevice.executeShellCommand(EasyMock.contains("chmod")))
                .andReturn("").times(2);
        mMockITestDevice.executeShellCommand(EasyMock.contains(test1), EasyMock.same(mMockReceiver),
                EasyMock.anyLong(), (TimeUnit)EasyMock.anyObject(), EasyMock.anyInt());
        mMockITestDevice.executeShellCommand(EasyMock.contains(test2), EasyMock.same(mMockReceiver),
                EasyMock.anyLong(), (TimeUnit)EasyMock.anyObject(), EasyMock.anyInt());
        EasyMock.expect(
                        mMockITestDevice.executeShellCommand(
                                String.format(
                                        "%s/test1 --benchmark_list_tests=true", nativeTestPath)))
                .andReturn("\nmethod1\nmethod2\nmethod3\n\n");
        EasyMock.expect(
                        mMockITestDevice.executeShellCommand(
                                String.format(
                                        "%s/test2 --benchmark_list_tests=true", nativeTestPath)))
                .andReturn("method1\nmethod2\n");
        mMockInvocationListener.testRunStarted(test1, 3);
        mMockInvocationListener.testStarted(mDummyTest);
        mMockInvocationListener.testEnded(
                EasyMock.eq(mDummyTest), EasyMock.<HashMap<String, String>>anyObject());
        mMockInvocationListener.testRunStarted(test2, 2);
        mMockInvocationListener.testStarted(mDummyTest);
        mMockInvocationListener.testEnded(
                EasyMock.eq(mDummyTest), EasyMock.<HashMap<String, String>>anyObject());
        mMockInvocationListener.testRunEnded(
                EasyMock.anyLong(), EasyMock.<HashMap<String, Metric>>anyObject());
        EasyMock.expectLastCall().times(2);
        replayMocks();

        mGoogleBenchmarkTest.run(mTestInfo, mMockInvocationListener);
        verifyMocks();
    }

    /**
     * Test the run method for a couple tests with a module name
     */
    public void testRun_withRunReportName() throws DeviceNotAvailableException {
        final String nativeTestPath = GoogleBenchmarkTest.DEFAULT_TEST_PATH;
        final String test1 = "test1";
        final String reportName = "reportName";
        mGoogleBenchmarkTest.setReportRunName(reportName);
        MockFileUtil.setMockDirContents(mMockITestDevice, nativeTestPath, test1);
        EasyMock.expect(mMockITestDevice.doesFileExist(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath + "/test1")).andReturn(false);
        String[] files = new String[] {"test1"};
        EasyMock.expect(mMockITestDevice.getChildren(nativeTestPath)).andReturn(files);
        EasyMock.expect(mMockITestDevice.executeShellCommand(EasyMock.contains("chmod")))
                .andReturn("");
        mMockITestDevice.executeShellCommand(EasyMock.contains(test1), EasyMock.same(mMockReceiver),
                EasyMock.anyLong(), (TimeUnit)EasyMock.anyObject(), EasyMock.anyInt());
        EasyMock.expect(
                        mMockITestDevice.executeShellCommand(
                                String.format(
                                        "%s/test1 --benchmark_list_tests=true", nativeTestPath)))
                .andReturn("method1\nmethod2\nmethod3");
        // Expect reportName instead of test name
        mMockInvocationListener.testRunStarted(reportName, 3);
        mMockInvocationListener.testStarted(mDummyTest);
        mMockInvocationListener.testEnded(
                EasyMock.eq(mDummyTest), EasyMock.<HashMap<String, String>>anyObject());
        mMockInvocationListener.testRunEnded(
                EasyMock.anyLong(), EasyMock.<HashMap<String, Metric>>anyObject());
        EasyMock.expectLastCall();
        replayMocks();

        mGoogleBenchmarkTest.run(mTestInfo, mMockInvocationListener);
        verifyMocks();
    }

    /**
     * Test the run method when exec shell throw exeception.
     */
    public void testRun_exceptionDuringExecShell() throws DeviceNotAvailableException {
        final String nativeTestPath = GoogleBenchmarkTest.DEFAULT_TEST_PATH;
        final String test1 = "test1";
        MockFileUtil.setMockDirContents(mMockITestDevice, nativeTestPath, test1);
        EasyMock.expect(mMockITestDevice.doesFileExist(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath + "/test1")).andReturn(false);
        String[] files = new String[] {"test1"};
        EasyMock.expect(mMockITestDevice.getChildren(nativeTestPath)).andReturn(files);
        EasyMock.expect(mMockITestDevice.executeShellCommand(EasyMock.contains("chmod")))
                .andReturn("");
        mMockITestDevice.executeShellCommand(EasyMock.contains(test1), EasyMock.same(mMockReceiver),
                EasyMock.anyLong(), (TimeUnit)EasyMock.anyObject(), EasyMock.anyInt());
        EasyMock.expectLastCall().andThrow(new DeviceNotAvailableException("dnae", "serial"));
        EasyMock.expect(
                        mMockITestDevice.executeShellCommand(
                                String.format(
                                        "%s/test1 --benchmark_list_tests=true", nativeTestPath)))
                .andReturn("method1\nmethod2\nmethod3");
        mMockInvocationListener.testRunStarted(test1, 3);
        mMockInvocationListener.testRunFailed((String) EasyMock.anyObject());
        // Even with exception testrunEnded is expected.
        mMockInvocationListener.testRunEnded(
                EasyMock.anyLong(), EasyMock.<HashMap<String, Metric>>anyObject());
        EasyMock.expectLastCall();
        replayMocks();

        try {
            mGoogleBenchmarkTest.run(mTestInfo, mMockInvocationListener);
            fail();
        } catch (DeviceNotAvailableException e) {
            // expected
        }
        verifyMocks();
    }

    /**
     * File exclusion regex filter should skip matched filepaths.
     */
    public void testFileExclusionRegexFilter_skipMatched() {
        // Skip files ending in .txt
        mGoogleBenchmarkTest.addFileExclusionFilterRegex(".*\\.txt");
        assertFalse(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/binary"));
        assertFalse(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/random.dat"));
        assertTrue(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/test.txt"));
        // Always skip files ending in .config
        assertTrue(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/random.config"));
    }

    /**
     * File exclusion regex filter for multi filters.
     */
    public void testFileExclusionRegexFilter_skipMultiMatched() {
        // Skip files ending in .txt
        mGoogleBenchmarkTest.addFileExclusionFilterRegex(".*\\.txt");
        // Also skip files ending in .dat
        mGoogleBenchmarkTest.addFileExclusionFilterRegex(".*\\.dat");
        assertFalse(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/binary"));
        assertTrue(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/random.dat"));
        assertTrue(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/test.txt"));
        // Always skip files ending in .config
        assertTrue(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/random.config"));
    }

    /** File exclusion regex filter should always skip .config file. */
    public void testFileExclusionRegexFilter_skipDefaultMatched() {
        // Always skip files ending in .config
        assertTrue(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/random.config"));
        // Other file should not be skipped
        assertFalse(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/random.configs"));
        assertFalse(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/binary"));
        assertFalse(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/random.dat"));
        assertFalse(mGoogleBenchmarkTest.shouldSkipFile("/some/path/file/test.txt"));

    }

    /** Test getFilterFlagForFilters. */
    public void testGetFilterFlagForFilters() {
        Set<String> filters = new LinkedHashSet<>(Arrays.asList("filter1", "filter2"));
        String filterFlag = mGoogleBenchmarkTest.getFilterFlagForFilters(filters);
        assertEquals(
                String.format(
                        " %s=%s",
                        GoogleBenchmarkTest.GBENCHMARK_FILTER_OPTION, "filter1\\|filter2"),
                filterFlag);
    }

    /** Test getFilterFlagForFilters - no filters. */
    public void testGetFilterFlagForFilters_noFilters() {
        Set<String> filters = new LinkedHashSet<>();
        String filterFlag = mGoogleBenchmarkTest.getFilterFlagForFilters(filters);
        assertEquals("", filterFlag);
    }

    /** Test getFilterFlagForTests. */
    public void testGetFilterFlagForTests() {
        Set<String> tests = new LinkedHashSet<>(Arrays.asList("test1", "test2"));
        String filterFlag = mGoogleBenchmarkTest.getFilterFlagForTests(tests);
        assertEquals(
                String.format(
                        " %s=%s",
                        GoogleBenchmarkTest.GBENCHMARK_FILTER_OPTION, "^test1$\\|^test2$"),
                filterFlag);
    }

    /** Test getFilterFlagForTests - no tests. */
    public void testGetFilterFlagForTests_noFilters() {
        Set<String> tests = new LinkedHashSet<>();
        String filterFlag = mGoogleBenchmarkTest.getFilterFlagForTests(tests);
        assertEquals("", filterFlag);
    }

    /**
     * Helper function to do the actual filtering test.
     *
     * @param incFilter filter flag for querying tests to include
     * @param incTests tests to include
     * @param excFilter filter flag for querying tests to exclude
     * @param excTests tests to exclude
     * @param testFilter filter flag for running tests
     * @throws DeviceNotAvailableException
     */
    private void doTestFilter(String incTests, String excTests, Set<String> filteredTests)
            throws DeviceNotAvailableException {
        String nativeTestPath = GoogleBenchmarkTest.DEFAULT_TEST_PATH;
        String testPath = nativeTestPath + "/test1";
        // configure the mock file system to have a single test
        MockFileUtil.setMockDirContents(mMockITestDevice, nativeTestPath, "test1");
        EasyMock.expect(mMockITestDevice.doesFileExist(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(testPath)).andReturn(false);
        EasyMock.expect(mMockITestDevice.executeShellCommand(EasyMock.contains("chmod")))
                .andReturn("");
        String[] files = new String[] {"test1"};
        EasyMock.expect(mMockITestDevice.getChildren(nativeTestPath)).andReturn(files);

        // List tests to include
        if (mGoogleBenchmarkTest.getIncludeFilters().size() > 0) {
            String incFilterFlag =
                    mGoogleBenchmarkTest.getFilterFlagForFilters(
                            mGoogleBenchmarkTest.getIncludeFilters());
            EasyMock.expect(mMockITestDevice.executeShellCommand(EasyMock.contains(incFilterFlag)))
                    .andReturn(incTests);
        } else {
            EasyMock.expect(
                            mMockITestDevice.executeShellCommand(
                                    EasyMock.not(
                                            EasyMock.contains(
                                                    GoogleBenchmarkTest.GBENCHMARK_FILTER_OPTION))))
                    .andReturn(incTests);
        }
        if (mGoogleBenchmarkTest.getExcludeFilters().size() > 0) {
            // List tests to exclude
            String excFilterFlag =
                    mGoogleBenchmarkTest.getFilterFlagForFilters(
                            mGoogleBenchmarkTest.getExcludeFilters());
            EasyMock.expect(mMockITestDevice.executeShellCommand(EasyMock.contains(excFilterFlag)))
                    .andReturn(excTests);
        }
        if (filteredTests != null && filteredTests.size() > 0) {
            // Runningt filtered tests
            String testFilterFlag = mGoogleBenchmarkTest.getFilterFlagForTests(filteredTests);
            mMockITestDevice.executeShellCommand(
                    EasyMock.contains(testFilterFlag),
                    EasyMock.same(mMockReceiver),
                    EasyMock.anyLong(),
                    (TimeUnit) EasyMock.anyObject(),
                    EasyMock.anyInt());
            mMockInvocationListener.testRunStarted("test1", filteredTests.size());
            mMockInvocationListener.testStarted(mDummyTest);
            mMockInvocationListener.testEnded(
                    EasyMock.eq(mDummyTest), EasyMock.<HashMap<String, String>>anyObject());
            mMockInvocationListener.testRunEnded(
                    EasyMock.anyLong(), EasyMock.<HashMap<String, Metric>>anyObject());
            EasyMock.expectLastCall();
        }
        replayMocks();

        mGoogleBenchmarkTest.run(mTestInfo, mMockInvocationListener);
        verifyMocks();
    }

    /** Test no matching tests for the filters. */
    public void testNoMatchingTests() throws DeviceNotAvailableException {
        Set<String> incFilters = new LinkedHashSet<>(Arrays.asList("X", "Y"));
        String incTests = "Failed to match any benchmarks against regex: X|Y";

        mGoogleBenchmarkTest.addAllIncludeFilters(incFilters);
        doTestFilter(incTests, null /* excTests */, null /* testFilter */);
    }

    /** Test the include filtering of test methods. */
    public void testIncludeFilter() throws DeviceNotAvailableException {
        Set<String> incFilters = new LinkedHashSet<>(Arrays.asList("A", "B"));
        String incTests = "A\nAa\nB\nBb";
        Set<String> filteredTests = new LinkedHashSet<>(Arrays.asList("A", "Aa", "B", "Bb"));

        mGoogleBenchmarkTest.addAllIncludeFilters(incFilters);
        doTestFilter(incTests, null /* excTests */, filteredTests);
    }

    /** Test the exclude filtering of test methods. */
    public void testExcludeFilter() throws DeviceNotAvailableException {
        String incTests = "A\nAa\nB\nBb\nC\nCc";
        Set<String> excFilters = new LinkedHashSet<>(Arrays.asList("Bb", "C"));
        String excTests = "Bb\nC\nCc";
        Set<String> filteredTests = new LinkedHashSet<>(Arrays.asList("A", "Aa", "B"));

        mGoogleBenchmarkTest.addAllExcludeFilters(excFilters);
        doTestFilter(incTests, excTests, filteredTests);
    }

    /** Test the include & exclude filtering of test methods. */
    public void testIncludeAndExcludeFilter() throws DeviceNotAvailableException {
        Set<String> incFilters = new LinkedHashSet<>(Arrays.asList("A", "B"));
        String incTests = "A\nAa\nB\nBb";
        Set<String> excFilters = new LinkedHashSet<>(Arrays.asList("Bb", "C"));
        String excTests = "Bb\nC\nCc";
        Set<String> filteredTests = new LinkedHashSet<>(Arrays.asList("A", "Aa", "B"));

        mGoogleBenchmarkTest.addAllIncludeFilters(incFilters);
        mGoogleBenchmarkTest.addAllExcludeFilters(excFilters);
        doTestFilter(incTests, excTests, filteredTests);
    }

    /** Test the ITestDescription filter format "class#method". */
    public void testClearFilter() throws DeviceNotAvailableException {
        Set<String> incFilters = new LinkedHashSet<>(Arrays.asList("X#A", "X#B"));
        Set<String> expectedIncFilters = new LinkedHashSet<>(Arrays.asList("A", "B"));
        mGoogleBenchmarkTest.addAllIncludeFilters(incFilters);
        assertEquals(expectedIncFilters, mGoogleBenchmarkTest.getIncludeFilters());
    }

    /** Test behavior for command lines too long to be run by ADB */
    public void testCommandTooLong() throws DeviceNotAvailableException {
        String deviceScriptPath = "/data/local/tmp/gbenchmarktest_script.sh";
        StringBuilder testNameBuilder = new StringBuilder();
        for (int i = 0; i < GoogleBenchmarkTest.ADB_CMD_CHAR_LIMIT; i++) {
            testNameBuilder.append("a");
        }
        String testName = testNameBuilder.toString();
        // filter string will be longer than GTest.ADB_CMD_CHAR_LIMIT

        String nativeTestPath = GoogleBenchmarkTest.DEFAULT_TEST_PATH;
        String testPath = nativeTestPath + "/" + testName;
        // configure the mock file system to have a single test
        MockFileUtil.setMockDirContents(mMockITestDevice, nativeTestPath, "test1");
        EasyMock.expect(mMockITestDevice.doesFileExist(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(nativeTestPath)).andReturn(true);
        EasyMock.expect(mMockITestDevice.isDirectory(testPath)).andReturn(false);
        EasyMock.expect(mMockITestDevice.executeShellCommand(EasyMock.contains("chmod")))
                .andReturn("");
        String[] files = new String[] {testName};
        EasyMock.expect(mMockITestDevice.getChildren(nativeTestPath)).andReturn(files);
        // List tests
        EasyMock.expect(
                        mMockITestDevice.pushString(
                                EasyMock.<String>anyObject(), EasyMock.eq(deviceScriptPath)))
                .andReturn(Boolean.TRUE);
        EasyMock.expect(
                        mMockITestDevice.executeShellCommand(
                                EasyMock.eq(String.format("sh %s", deviceScriptPath))))
                .andReturn("test");
        mMockITestDevice.deleteFile(deviceScriptPath);
        // Run tests
        EasyMock.expect(
                        mMockITestDevice.pushString(
                                EasyMock.<String>anyObject(), EasyMock.eq(deviceScriptPath)))
                .andReturn(Boolean.TRUE);
        mMockITestDevice.executeShellCommand(
                EasyMock.eq(String.format("sh %s", deviceScriptPath)),
                EasyMock.same(mMockReceiver),
                EasyMock.anyLong(),
                (TimeUnit) EasyMock.anyObject(),
                EasyMock.anyInt());
        mMockITestDevice.deleteFile(deviceScriptPath);
        mMockInvocationListener.testRunStarted(testName, 1);
        mMockInvocationListener.testStarted(mDummyTest);
        mMockInvocationListener.testEnded(
                EasyMock.eq(mDummyTest), EasyMock.<HashMap<String, String>>anyObject());
        mMockInvocationListener.testRunEnded(
                EasyMock.anyLong(), EasyMock.<HashMap<String, Metric>>anyObject());
        EasyMock.expectLastCall();
        replayMocks();

        mGoogleBenchmarkTest.run(mTestInfo, mMockInvocationListener);
        verifyMocks();
    }
}