1 files changed, 211 insertions, 0 deletions
diff --git a/src/test/java/com/google/testing/junit/testparameterinjector/TestParameterTest.java b/src/test/java/com/google/testing/junit/testparameterinjector/TestParameterTest.java
new file mode 100644
index 0000000..b16d5e1
--- /dev/null
+++ b/src/test/java/com/google/testing/junit/testparameterinjector/TestParameterTest.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright 2021 Google Inc.
+ *
+ * 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.google.testing.junit.testparameterinjector;
+
+import static com.google.common.collect.ImmutableList.toImmutableList;
+import static com.google.common.collect.Lists.newArrayList;
+import static com.google.common.truth.Truth.assertThat;
+import static com.google.common.truth.Truth.assertWithMessage;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import com.google.common.base.CharMatcher;
+import com.google.testing.junit.testparameterinjector.TestParameter.TestParameterValuesProvider;
+import java.lang.annotation.Retention;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runner.notification.Failure;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/** Test class to test the @TestParameter's value provider. */
+@RunWith(Parameterized.class)
+public class TestParameterTest {
+
+  @Retention(RUNTIME)
+  @interface RunAsTest {}
+
+  public enum TestEnum {
+    ONE,
+    TWO,
+    THREE,
+  }
+
+  @RunAsTest
+  public static class AnnotatedField {
+    private static List<TestEnum> testedParameters;
+
+    @TestParameter TestEnum enumParameter;
+
+    @BeforeClass
+    public static void initializeStaticFields() {
+      assertWithMessage("Expecting this class to be run only once").that(testedParameters).isNull();
+      testedParameters = new ArrayList<>();
+    }
+
+    @Test
+    public void test() {
+      testedParameters.add(enumParameter);
+    }
+
+    @AfterClass
+    public static void completedAllParameterizedTests() {
+      assertThat(testedParameters).containsExactly(TestEnum.ONE, TestEnum.TWO, TestEnum.THREE);
+    }
+  }
+
+  @RunAsTest
+  public static class AnnotatedConstructorParameter {
+    private static List<TestEnum> testedParameters;
+
+    private final TestEnum enumParameter;
+
+    public AnnotatedConstructorParameter(@TestParameter TestEnum enumParameter) {
+      this.enumParameter = enumParameter;
+    }
+
+    @BeforeClass
+    public static void initializeStaticFields() {
+      assertWithMessage("Expecting this class to be run only once").that(testedParameters).isNull();
+      testedParameters = new ArrayList<>();
+    }
+
+    @Test
+    public void test() {
+      testedParameters.add(enumParameter);
+    }
+
+    @AfterClass
+    public static void completedAllParameterizedTests() {
+      assertThat(testedParameters).containsExactly(TestEnum.ONE, TestEnum.TWO, TestEnum.THREE);
+    }
+  }
+
+  @RunAsTest
+  public static class MultipleAnnotatedParameters {
+    private static List<String> testedParameters;
+
+    @BeforeClass
+    public static void initializeStaticFields() {
+      assertWithMessage("Expecting this class to be run only once").that(testedParameters).isNull();
+      testedParameters = new ArrayList<>();
+    }
+
+    @Test
+    public void test(
+        @TestParameter TestEnum enumParameterA,
+        @TestParameter({"TWO", "THREE"}) TestEnum enumParameterB,
+        @TestParameter({"!!binary 'ZGF0YQ=='", "data2"}) byte[] bytes) {
+      testedParameters.add(
+          String.format("%s:%s:%s", enumParameterA, enumParameterB, new String(bytes)));
+    }
+
+    @AfterClass
+    public static void completedAllParameterizedTests() {
+      assertThat(testedParameters)
+          .containsExactly(
+              "ONE:TWO:data",
+              "ONE:THREE:data",
+              "TWO:TWO:data",
+              "TWO:THREE:data",
+              "THREE:TWO:data",
+              "THREE:THREE:data",
+              "ONE:TWO:data2",
+              "ONE:THREE:data2",
+              "TWO:TWO:data2",
+              "TWO:THREE:data2",
+              "THREE:TWO:data2",
+              "THREE:THREE:data2");
+    }
+  }
+
+  @RunAsTest
+  public static class WithValuesProvider {
+    private static List<Object> testedParameters;
+
+    @BeforeClass
+    public static void initializeStaticFields() {
+      assertWithMessage("Expecting this class to be run only once").that(testedParameters).isNull();
+      testedParameters = new ArrayList<>();
+    }
+
+    @Test
+    public void stringTest(
+        @TestParameter(valuesProvider = TestStringProvider.class) String string) {
+      testedParameters.add(string);
+    }
+
+    @Test
+    public void charMatcherTest(
+        @TestParameter(valuesProvider = CharMatcherProvider.class) CharMatcher charMatcher) {
+      testedParameters.add(charMatcher);
+    }
+
+    @AfterClass
+    public static void completedAllParameterizedTests() {
+      assertThat(testedParameters)
+          .containsExactly(
+              "A", "B", null, CharMatcher.any(), CharMatcher.ascii(), CharMatcher.whitespace());
+    }
+
+    private static final class TestStringProvider implements TestParameterValuesProvider {
+      @Override
+      public List<String> provideValues() {
+        return newArrayList("A", "B", null);
+      }
+    }
+
+    private static final class CharMatcherProvider implements TestParameterValuesProvider {
+      @Override
+      public List<CharMatcher> provideValues() {
+        return newArrayList(CharMatcher.any(), CharMatcher.ascii(), CharMatcher.whitespace());
+      }
+    }
+  }
+
+  @Parameters(name = "{0}")
+  public static Collection<Object[]> parameters() {
+    return Arrays.stream(TestParameterTest.class.getClasses())
+        .filter(cls -> cls.isAnnotationPresent(RunAsTest.class))
+        .map(cls -> new Object[] {cls.getSimpleName(), cls})
+        .collect(toImmutableList());
+  }
+
+  private final Class<?> testClass;
+
+  public TestParameterTest(String name, Class<?> testClass) {
+    this.testClass = testClass;
+  }
+
+  @Test
+  public void test() throws Exception {
+    List<Failure> failures =
+        PluggableTestRunner.run(
+            new PluggableTestRunner(testClass) {
+              @Override
+              protected List<TestMethodProcessor> createTestMethodProcessorList() {
+                return TestMethodProcessors.createNewParameterizedProcessorsWithLegacyFeatures(
+                    getTestClass());
+              }
+            });
+
+    assertThat(failures).isEmpty();
+  }
+}