[Android] Support conditional test disabling based on android.os.Build values.

base/test/android/javatests/src/org/chromium/base/test/BaseInstrumentationTestRunner.java

 // Copyright 2014 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;
 
 import android.content.Context;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.os.Build;
 import android.os.Bundle;
 import android.test.AndroidTestRunner;
 import android.test.InstrumentationTestRunner;
 import android.text.TextUtils;
 
 import junit.framework.TestCase;
 import junit.framework.TestResult;
 
 import org.chromium.base.Log;
 import org.chromium.base.SysUtils;
 import org.chromium.base.multidex.ChromiumMultiDex;
 import org.chromium.base.test.BaseTestResult.SkipCheck;
 import org.chromium.base.test.util.CommandLineFlags;
+import org.chromium.base.test.util.DisableIf;
 import org.chromium.base.test.util.MinAndroidSdkLevel;
 import org.chromium.base.test.util.Restriction;
 import org.chromium.test.reporter.TestStatusListener;
 
 import java.lang.reflect.Method;
+import java.util.Arrays;
 
 // TODO(jbudorick): Add support for on-device handling of timeouts.
 /**
  *  An Instrumentation test runner that checks SDK level for tests with specific requirements.
  */
 public class BaseInstrumentationTestRunner extends InstrumentationTestRunner {
     private static final String TAG = "base_test";
 
     @Override
     public void onCreate(Bundle arguments) {
@@ skipping 18 matching lines @@
     /**
      * Override this method to register hooks and checks to be run for each test. Make sure to call
      * the base implementation if you do so.
      *
      * @see BaseTestResult#addSkipCheck(BaseTestResult.SkipCheck)
      * @see BaseTestResult#addPreTestHook(BaseTestResult.PreTestHook)
      */
     protected void addTestHooks(BaseTestResult result) {
         result.addSkipCheck(new MinAndroidSdkLevelSkipCheck());
         result.addSkipCheck(new RestrictionSkipCheck());
+        result.addSkipCheck(new DisableSkipCheck());
 
         result.addPreTestHook(CommandLineFlags.getRegistrationHook());
     }
 
+    private static Method getTestMethod(TestCase testCase) {
+        try {
+            return testCase.getClass().getMethod(testCase.getName(), (Class[]) null);
+        } catch (NoSuchMethodException e) {
+            Log.e(TAG, "Unable to find %s in %s", testCase.getName(),
+                    testCase.getClass().getName(), e);
+            return null;
+        }
+    }
+
     /**
      * Checks if any restrictions exist and skip the test if it meets those restrictions.
      */
     public class RestrictionSkipCheck implements SkipCheck {
         @Override
         public boolean shouldSkip(TestCase testCase) {
-            Method method;
-            try {
-                method = testCase.getClass().getMethod(testCase.getName(), (Class[]) null);
-            } catch (NoSuchMethodException e) {
-                Log.e(TAG, "Unable to find %s in %s", testCase.getName(),
-                        testCase.getClass().getName(), e);
-                return true;
-            }
+            Method method = getTestMethod(testCase);
+            if (method == null) return true;
+
             Restriction restrictions = method.getAnnotation(Restriction.class);
             if (restrictions != null) {
                 for (String restriction : restrictions.value()) {
                     if (restrictionApplies(restriction)) {
                         return true;
                     }
                 }
             }
             return false;
         }
@@ skipping 16 matching lines @@
 
         private boolean isNetworkAvailable() {
             final ConnectivityManager connectivityManager = (ConnectivityManager)
                     getTargetContext().getSystemService(Context.CONNECTIVITY_SERVICE);
             final NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
             return activeNetworkInfo != null && activeNetworkInfo.isConnected();
         }
     }
 
     /**
+     * Checks for conditional disables.
+     *
+     * Currently, this only includes checks against a few {@link android.os.Build} values.
+     */
+    public static class DisableIfSkipCheck implements SkipCheck {
+
+        @Override
+        public boolean shouldSkip(TestCase testCase) {
+            Method method = getTestMethod(testCase);
+            if (method == null) return true;
+
+            if (method.isAnnotationPresent(DisableIf.Build.class)) {
+                DisableIf.Build v = method.getAnnotation(
+                        DisableIf.Build.class);
+                return sdk(v) && abi(v) && hardware(v);
+            }
+
+            return false;
+        }
+
+        private boolean sdk(DisableIf.Build v) {
+            return Build.VERSION.SDK_INT < v.sdk_is_less_than()

[Yaron, 2015/12/11 02:22:16]

*sigh*

I guess I'll eventually lose this battle of only allowing restricting tests for
SDK>=X. IMHO we shouldn't have tests that stop working at some API level cause
we don't have features implemented that way :(

[jbudorick, 2015/12/17 02:08:13]

I'm fine with leaving this out until someone needs it.

+                    && Build.VERSION.SDK_INT > v.sdk_is_greater_than();
+        }
+
+        private boolean abi(DisableIf.Build v) {
+            if (v.supported_abis_includes().isEmpty()) return true;
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                for (String s : Build.SUPPORTED_ABIS) {
+                    Log.i(TAG, "  %s", s);

[Yaron, 2015/12/11 02:22:16]

?

[jbudorick, 2015/12/17 02:08:13]

leftover, removed.

+                }
+                return Arrays.asList(Build.SUPPORTED_ABIS).contains(
+                        v.supported_abis_includes());

[Yaron, 2015/12/11 02:22:16]

would you need to strip this on spaces or can you only specify one?

[jbudorick, 2015/12/17 02:08:13]

at the moment, only one.

+            } else {
+                return Build.CPU_ABI.equals(v.supported_abis_includes())
+                        || Build.CPU_ABI2.equals(v.supported_abis_includes());
+            }
+        }
+
+        private boolean hardware(DisableIf.Build v) {
+            return v.hardware_is().isEmpty() || Build.HARDWARE.equals(v.hardware_is());
+        }
+    }
+
+    /**
      * Checks the device's SDK level against any specified minimum requirement.
      */
     public static class MinAndroidSdkLevelSkipCheck implements SkipCheck {
 
         /**
          * If {@link MinAndroidSdkLevel} is present, checks its value
          * against the device's SDK level.
          *
          * @param testCase The test to check.
          * @return true if the device's SDK level is below the specified minimum.
          */
         @Override
         public boolean shouldSkip(TestCase testCase) {
             Class<?> testClass = testCase.getClass();
             if (testClass.isAnnotationPresent(MinAndroidSdkLevel.class)) {
                 MinAndroidSdkLevel v = testClass.getAnnotation(MinAndroidSdkLevel.class);
                 if (Build.VERSION.SDK_INT < v.value()) {
                     Log.i(TAG, "Test " + testClass.getName() + "#" + testCase.getName()
                             + " is not enabled at SDK level " + Build.VERSION.SDK_INT
                             + ".");
                     return true;
                 }
             }
             return false;
         }
     }
 }