Merge pull request #1692 from tulinkry/conditional-repeatable

making the conditional rules in tests repeatable

Author: tarzanek

test/org/opensolaris/opengrok/condition/ConditionalRun.java

@@ -18,19 +18,27 @@
  */
 
  /*
- * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
  */
 package org.opensolaris.opengrok.condition;
 
 import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Repeatable;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+/**
+ * Repeatable annotation for automatic test skipping.
+ */
 @Retention(RetentionPolicy.RUNTIME)
-@Target(value = {ElementType.METHOD, ElementType.TYPE})
+@Target(value = {ElementType.METHOD, ElementType.TYPE, ElementType.PACKAGE})
+@Repeatable(ConditionalRunRepeatable.class)
+@Inherited
 @Documented
 public @interface ConditionalRun {
+
     Class<? extends RunCondition> condition();
 }

test/org/opensolaris/opengrok/condition/ConditionalRunRepeatable.java

@@ -0,0 +1,45 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * See LICENSE.txt included in this distribution for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at LICENSE.txt.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+ /*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ */
+package org.opensolaris.opengrok.condition;
+
+import java.lang.annotation.Documented;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+/**
+ * Annotation allowing the {@link ConditionalRun} to be repeatable annotation.
+ *
+ * @author Krystof Tulinger
+ */
+@Retention(value = RUNTIME)
+@Documented
+@Inherited
+@Target(value = {ElementType.METHOD, ElementType.TYPE, ElementType.PACKAGE})
+public @interface ConditionalRunRepeatable {
+
+    ConditionalRun[] value();
+}

test/org/opensolaris/opengrok/condition/ConditionalRunRule.java

@@ -18,17 +18,20 @@
  */
 
  /*
- * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
  */
 package org.opensolaris.opengrok.condition;
 
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
 import org.junit.Assume;
 import org.junit.rules.TestRule;
 import org.junit.runner.Description;
 import org.junit.runners.model.Statement;
 
-import java.lang.reflect.Modifier;
-
 /**
  *
  * This rule can be added to a Junit test and will look for the annotation
@@ -41,6 +44,7 @@
  * https://gist.github.com/yinzara/9980184
  * http://cwd.dhemery.com/2010/12/junit-rules/
  * http://stackoverflow.com/questions/28145735/androidjunit4-class-org-junit-assume-assumetrue-assumptionviolatedexception/
+ * https://docs.oracle.com/javase/tutorial/java/annotations/repeating.html
  */
 public class ConditionalRunRule implements TestRule {
 
@@ -64,34 +68,70 @@ public Statement apply(Statement aStatement, Description aDescription) {
     }
 
     private static boolean hasConditionalIgnoreAnnotationOnClass(Description aDescription) {
-        return aDescription.getTestClass().getAnnotation(ConditionalRun.class) != null;
+        return aDescription.getTestClass().getAnnotationsByType(ConditionalRun.class).length > 0;
     }
 
     private static RunCondition getIgnoreConditionOnClass(Description aDescription) {
-        ConditionalRun annotation = aDescription.getTestClass().getAnnotation(ConditionalRun.class);
-        return new IgnoreConditionCreator(aDescription.getTestClass(), annotation).create();
+        ConditionalRun[] annotations = aDescription.getTestClass().getAnnotationsByType(ConditionalRun.class);
+        return new IgnoreConditionCreator(aDescription.getTestClass(), annotations).create();
     }
 
     private static boolean hasConditionalIgnoreAnnotationOnMethod(Description aDescription) {
-        return aDescription.getAnnotation(ConditionalRun.class) != null;
+        try {
+            // this is possible because test methods must not have any argument
+            Method testMethod = aDescription.getTestClass().getMethod(aDescription.getMethodName());
+            return testMethod.getAnnotationsByType(ConditionalRun.class).length > 0;
+        } catch (NoSuchMethodException | SecurityException ex) {
+            throw new RuntimeException(ex);
+        }
     }
 
     private static RunCondition getIgnoreConditionOnMethod(Description aDescription) {
-        ConditionalRun annotation = aDescription.getAnnotation(ConditionalRun.class);
-        return new IgnoreConditionCreator(aDescription.getTestClass(), annotation).create();
+        try {
+            // this is possible because test methods must not have any argument
+            ConditionalRun[] annotations = aDescription.getTestClass().getMethod(aDescription.getMethodName()).getAnnotationsByType(ConditionalRun.class);
+            return new IgnoreConditionCreator(aDescription.getTestClass(), annotations).create();
+        } catch (NoSuchMethodException | SecurityException ex) {
+            throw new RuntimeException(ex);
+        }
     }
 
-    private static class IgnoreConditionCreator {
+    /**
+     * Container for several conditions joined by an AND operator.
+     */
+    protected static class CompositeCondition implements RunCondition {
+
+        List<RunCondition> conditions = new LinkedList<>();
+
+        public boolean add(RunCondition e) {
+            return conditions.add(e);
+        }
+
+        @Override
+        public boolean isSatisfied() {
+            for (RunCondition condition : conditions) {
+                if (!condition.isSatisfied()) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    protected static class IgnoreConditionCreator {
 
         private final Class<?> mTestClass;
-        private final Class<? extends RunCondition> conditionType;
+        private final List<Class<? extends RunCondition>> conditionTypes;
 
-        IgnoreConditionCreator(Class<?> aTestClass, ConditionalRun annotation) {
+        public IgnoreConditionCreator(Class<?> aTestClass, ConditionalRun[] annotation) {
             this.mTestClass = aTestClass;
-            this.conditionType = annotation.condition();
+            this.conditionTypes = new ArrayList<>(annotation.length);
+            for (int i = 0; i < annotation.length; i++) {
+                this.conditionTypes.add(i, annotation[i].condition());
+            }
         }
 
-        RunCondition create() {
+        public RunCondition create() {
             checkConditionType();
             try {
                 return createCondition();
@@ -103,38 +143,49 @@ RunCondition create() {
         }
 
         private RunCondition createCondition() throws Exception {
-            RunCondition result;
-            if (isConditionTypeStandalone()) {
-                result = conditionType.newInstance();
-            } else {
-                result = conditionType.getDeclaredConstructor(mTestClass).newInstance(mTestClass);
+            CompositeCondition result = null;
+            /**
+             * Run through the list of classes implementing RunCondition and
+             * create a new class from it.
+             */
+            for (Class<? extends RunCondition> clazz : conditionTypes) {
+                if (result == null) {
+                    result = new CompositeCondition();
+                }
+                if (isConditionTypeStandalone(clazz)) {
+                    result.add(clazz.newInstance());
+                } else {
+                    result.add(clazz.getDeclaredConstructor(mTestClass).newInstance(mTestClass));
+                }
             }
             return result;
         }
 
         private void checkConditionType() {
-            if (!isConditionTypeStandalone() && !isConditionTypeDeclaredInTarget()) {
-                String msg
-                        = "Conditional class '%s' is a member class "
-                        + "but was not declared inside the test case using it.\n"
-                        + "Either make this class a static class, "
-                        + "standalone class (by declaring it in it's own file) "
-                        + "or move it inside the test case using it";
-                throw new IllegalArgumentException(String.format(msg, conditionType.getName()));
+            for (Class<? extends RunCondition> clazz : conditionTypes) {
+                if (!isConditionTypeStandalone(clazz) && !isConditionTypeDeclaredInTarget(clazz)) {
+                    String msg
+                            = "Conditional class '%s' is a member class "
+                            + "but was not declared inside the test case using it.\n"
+                            + "Either make this class a static class, "
+                            + "standalone class (by declaring it in it's own file) "
+                            + "or move it inside the test case using it";
+                    throw new IllegalArgumentException(String.format(msg, clazz.getName()));
+                }
             }
         }
 
-        private boolean isConditionTypeStandalone() {
-            return !conditionType.isMemberClass()
-                    || Modifier.isStatic(conditionType.getModifiers());
+        private boolean isConditionTypeStandalone(Class<? extends RunCondition> clazz) {
+            return !clazz.isMemberClass()
+                    || Modifier.isStatic(clazz.getModifiers());
         }
 
-        private boolean isConditionTypeDeclaredInTarget() {
-            return mTestClass.getClass().isAssignableFrom(conditionType.getDeclaringClass());
+        private boolean isConditionTypeDeclaredInTarget(Class<? extends RunCondition> clazz) {
+            return mTestClass.getClass().isAssignableFrom(clazz.getDeclaringClass());
         }
     }
 
-    private static class IgnoreStatement extends Statement {
+    protected static class IgnoreStatement extends Statement {
 
         private final RunCondition condition;
 

test/org/opensolaris/opengrok/condition/RunCondition.java

@@ -18,11 +18,11 @@
  */
 
  /*
- * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
  */
 package org.opensolaris.opengrok.condition;
 
 public interface RunCondition {
 
-    boolean isSatisfied();
+    public boolean isSatisfied();
 }

test/org/opensolaris/opengrok/condition/RunningRepeatableConditionTest.java

@@ -0,0 +1,75 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * See LICENSE.txt included in this distribution for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at LICENSE.txt.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+ /*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ */
+package org.opensolaris.opengrok.condition;
+
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+
+/**
+ *
+ * @author Krystof Tulinger
+ */
+@ConditionalRun(condition = RunningRepeatableConditionTest.TrueRunCondition.class)
+@ConditionalRun(condition = RunningRepeatableConditionTest.TrueRunCondition.class)
+@ConditionalRun(condition = RunningRepeatableConditionTest.TrueRunCondition.class)
+public class RunningRepeatableConditionTest {
+
+    @Rule
+    public ConditionalRunRule rule = new ConditionalRunRule();
+
+    @ConditionalRun(condition = TrueRunCondition.class)
+    @ConditionalRun(condition = TrueRunCondition.class)
+    @ConditionalRun(condition = TrueRunCondition.class)
+    @ConditionalRun(condition = TrueRunCondition.class)
+    @ConditionalRun(condition = TrueRunCondition.class)
+    @Test
+    public void testRunningTest() {
+        Assert.assertTrue("This test shall run", true);
+    }
+
+    @ConditionalRun(condition = TrueRunCondition.class)
+    @ConditionalRun(condition = FalseRunCondition.class)
+    @ConditionalRun(condition = TrueRunCondition.class)
+    @Test
+    public void testSkippedTest() throws NoSuchMethodException {
+        Assert.assertTrue("This test must be skipped", false);
+    }
+
+    protected static class TrueRunCondition implements RunCondition {
+
+        @Override
+        public boolean isSatisfied() {
+            return true;
+        }
+    }
+
+    protected static class FalseRunCondition implements RunCondition {
+
+        @Override
+        public boolean isSatisfied() {
+            return false;
+        }
+    }
+
+}

test/org/opensolaris/opengrok/condition/SkippingRepeatableConditionTest.java

@@ -0,0 +1,41 @@
+/*
+ * CDDL HEADER START
+ *
+ * The contents of this file are subject to the terms of the
+ * Common Development and Distribution License (the "License").
+ * You may not use this file except in compliance with the License.
+ *
+ * See LICENSE.txt included in this distribution for the specific
+ * language governing permissions and limitations under the License.
+ *
+ * When distributing Covered Code, include this CDDL HEADER in each
+ * file and include the License file at LICENSE.txt.
+ * If applicable, add the following below this CDDL HEADER, with the
+ * fields enclosed by brackets "[]" replaced with your own identifying
+ * information: Portions Copyright [yyyy] [name of copyright owner]
+ *
+ * CDDL HEADER END
+ */
+
+ /*
+ * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+ */
+package org.opensolaris.opengrok.condition;
+
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+
+@ConditionalRun(condition = RunningRepeatableConditionTest.TrueRunCondition.class)
+@ConditionalRun(condition = RunningRepeatableConditionTest.FalseRunCondition.class)
+@ConditionalRun(condition = RunningRepeatableConditionTest.TrueRunCondition.class)
+public class SkippingRepeatableConditionTest {
+
+    @Rule
+    public ConditionalRunRule rule = new ConditionalRunRule();
+
+    @Test
+    public void testSkippedTest() throws NoSuchMethodException {
+        Assert.assertTrue("This test must be skipped", false);
+    }
+}