Create Next Gen Parameter Test Framework for JUnit4

base/test/android/junit/src/org/chromium/base/test/params/ParameterizedRunnerDelegateFactoryTest.java

Index: base/test/android/junit/src/org/chromium/base/test/params/ParameterizedRunnerDelegateFactoryTest.java
diff --git a/base/test/android/junit/src/org/chromium/base/test/params/ParameterizedRunnerDelegateFactoryTest.java b/base/test/android/junit/src/org/chromium/base/test/params/ParameterizedRunnerDelegateFactoryTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..3be81a92692d32fae33d5368515271c6ef6a6a95
--- /dev/null
+++ b/base/test/android/junit/src/org/chromium/base/test/params/ParameterizedRunnerDelegateFactoryTest.java
@@ -0,0 +1,191 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.base.test.params;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.BlockJUnit4ClassRunner;
+import org.junit.runners.model.FrameworkMethod;
+import org.junit.runners.model.InitializationError;
+import org.junit.runners.model.TestClass;
+
+import org.chromium.base.test.params.ParameterAnnotations.UseMethodParameter;
+import org.chromium.base.test.params.ParameterizedRunner.ParameterizedTestInstantiationException;
+import org.chromium.base.test.params.ParameterizedRunnerDelegateFactory.ParameterizedRunnerDelegateInstantiationException;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Test for org.chromium.base.test.params.ParameterizedRunnerDelegateFactory
+ */
+@RunWith(BlockJUnit4ClassRunner.class)
+public class ParameterizedRunnerDelegateFactoryTest {
+    /**
+     * This RunnerDelegate calls `super.collectInitializationErrors()` and would
+     * cause BlockJUnit4ClassRunner to validate test classes.
+     */
+    public static class BadExampleRunnerDelegate
+            extends BlockJUnit4ClassRunner implements ParameterizedRunnerDelegate {
+        public static class LalaTestClass {}
+
+        private final List<FrameworkMethod> mParameterizedFrameworkMethodList;
+
+        BadExampleRunnerDelegate(Class<?> klass,
+                List<FrameworkMethod> parameterizedFrameworkMethods) throws InitializationError {
+            super(klass);
+            mParameterizedFrameworkMethodList = parameterizedFrameworkMethods;
+        }
+
+        @Override
+        public void collectInitializationErrors(List<Throwable> errors) {
+            super.collectInitializationErrors(errors); // This is wrong!!
+        }
+
+        @Override
+        public List<FrameworkMethod> computeTestMethods() {
+            return mParameterizedFrameworkMethodList;
+        }
+
+        @Override
+        public Object createTest() {
+            return null;
+        }
+    }
+
+    static class BadTestClassWithMoreThanOneConstructor {
+        public BadTestClassWithMoreThanOneConstructor() {}
+        @SuppressWarnings("unused")
+        public BadTestClassWithMoreThanOneConstructor(String argument) {}
+    }
+
+    static class TestClassConstructorWithTwoArguments {
+        @SuppressWarnings("unused")
+        public TestClassConstructorWithTwoArguments(int a, int b) {}
+    }
+
+    static class ExampleTestClass {
+        @SuppressWarnings("unused")
+        @UseMethodParameter("A")
+        @Test
+        public void testA(String a) {}
+
+        @SuppressWarnings("unused")
+        @UseMethodParameter("B")
+        @Test
+        public void testB(int b) {}
+
+        @Test
+        public void testByMyself() {}
+    }
+
+    /**
+     * This test validates ParameterizedRunnerDelegateFactory throws exception when
+     * a runner delegate does not override the collectInitializationErrors method.
+     */
+    @Test(expected = ParameterizedRunnerDelegateInstantiationException.class)
+    public void testBadRunnerDelegateWithIncorrectValidationCall() throws Throwable {
+        ParameterizedRunnerDelegateFactory factory = new ParameterizedRunnerDelegateFactory();
+        TestClass testClass = new TestClass(BadExampleRunnerDelegate.LalaTestClass.class);
+        factory.createRunner(
+                testClass, null, Collections.emptyMap(), BadExampleRunnerDelegate.class);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testCreateTestWithMoreThanOneConstructor() throws Throwable {
+        TestClass testClass = new TestClass(BadTestClassWithMoreThanOneConstructor.class);
+        ParameterizedRunnerDelegateFactory.createTest(testClass, new ParameterSet());
+    }
+
+    @Test(expected = ParameterizedTestInstantiationException.class)
+    public void testCreateTestWithIncorrectArguments() throws Throwable {
+        TestClass testClass = new TestClass(TestClassConstructorWithTwoArguments.class);
+        ParameterSet pSet = new ParameterSet().value(1, 2, 3);
+        ParameterizedRunnerDelegateFactory.createTest(testClass, pSet);
+    }
+
+    @Test
+    public void testGenerateParameterizedFrameworkMethod() throws Throwable {
+        Map<String, List<ParameterSet>> map = new HashMap<>();
+        List<ParameterSet> listA = new ArrayList<>();
+        listA.add(new ParameterSet().value("a").name("testWithValue_a"));
+        listA.add(new ParameterSet().value("b").name("testWithValue_b"));
+
+        List<ParameterSet> listB = new ArrayList<>();
+        listB.add(new ParameterSet().value(1).name("testWithValue_1"));
+        listB.add(new ParameterSet().value(2).name("testWithValue_2"));
+        listB.add(new ParameterSet().value(3).name("testWithValue_3"));
+        map.put("A", listA);
+        map.put("B", listB);
+
+        List<FrameworkMethod> methods =
+                ParameterizedRunnerDelegateFactory.generateUnmodifiableFrameworkMethodList(
+                        new TestClass(ExampleTestClass.class), map, "");
+
+        Assert.assertEquals(methods.size(), 6);
+
+        Map<String, Method> expectedTests = new HashMap<>();
+        Method testMethodA = ExampleTestClass.class.getDeclaredMethod("testA", String.class);
+        Method testMethodB = ExampleTestClass.class.getDeclaredMethod("testB", int.class);
+        Method testMethodByMyself = ExampleTestClass.class.getDeclaredMethod("testByMyself");
+        expectedTests.put("testA__testWithValue_a", testMethodA);
+        expectedTests.put("testA__testWithValue_b", testMethodA);
+        expectedTests.put("testB__testWithValue_1", testMethodB);
+        expectedTests.put("testB__testWithValue_2", testMethodB);
+        expectedTests.put("testB__testWithValue_3", testMethodB);
+        expectedTests.put("testByMyself", testMethodByMyself);
+        for (FrameworkMethod method : methods) {
+            Assert.assertNotNull(expectedTests.get(method.getName()));
+            Assert.assertEquals(expectedTests.get(method.getName()), method.getMethod());
+            expectedTests.remove(method.getName());
+        }
+        Assert.assertTrue(expectedTests.isEmpty());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testEmptyParameterSet() {
+        Map<String, List<ParameterSet>> map = new HashMap<>();
+        List<ParameterSet> listA = new ArrayList<>();
+        listA.add(new ParameterSet().value("a").name("testWithValue_a"));
+        List<ParameterSet> listB = new ArrayList<>();
+        listB.add(new ParameterSet()); //Empty parameter set
+        map.put("A", listA);
+        map.put("B", listB);
+        ParameterizedRunnerDelegateFactory.generateUnmodifiableFrameworkMethodList(
+                new TestClass(ExampleTestClass.class), map, "");
+    }
+
+    @Test(expected = AssertionError.class)
+    public void testMissingParameterSet() {
+        Map<String, List<ParameterSet>> map = new HashMap<>();
+        List<ParameterSet> listA = new ArrayList<>();
+        listA.add(new ParameterSet().value("a").name("testWithValue_a"));
+        map.put("A", listA);
+        //Missing ParameterSet list under group "B"
+        ParameterizedRunnerDelegateFactory.generateUnmodifiableFrameworkMethodList(
+                new TestClass(ExampleTestClass.class), map, "");
+    }
+
+    @Test(expected = AssertionError.class)
+    public void testMissingTestMethod() {
+        Map<String, List<ParameterSet>> map = new HashMap<>();
+        List<ParameterSet> listA = new ArrayList<>();
+        listA.add(new ParameterSet().value("a").name("testWithValue_a"));
+        List<ParameterSet> listB = new ArrayList<>();
+        listB.add(new ParameterSet().value(1).name("testWithValue_1"));
+        List<ParameterSet> listC = new ArrayList<>();
+        listC.add(new ParameterSet().value(10).name("extra"));
+        map.put("A", listA);
+        map.put("B", listB);
+        map.put("C", listC);
+        ParameterizedRunnerDelegateFactory.generateUnmodifiableFrameworkMethodList(
+                new TestClass(ExampleTestClass.class), map, "");
+    }
+}