[Android] JUnit runner + gyp changes.

testing/android/junit/java/src/org/chromium/testing/local/GtestFilter.java

Index: testing/android/junit/java/src/org/chromium/testing/local/GtestFilter.java
diff --git a/testing/android/junit/java/src/org/chromium/testing/local/GtestFilter.java b/testing/android/junit/java/src/org/chromium/testing/local/GtestFilter.java
new file mode 100644
index 0000000000000000000000000000000000000000..68dcbb8716d3258f588993ab059b81e6eec5e898
--- /dev/null
+++ b/testing/android/junit/java/src/org/chromium/testing/local/GtestFilter.java
@@ -0,0 +1,95 @@
+// 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.testing.local;
+
+import org.junit.runner.Description;
+import org.junit.runner.manipulation.Filter;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/**
+ *  Filters tests based on a googletest-style filter string.
+ */
+class GtestFilter extends Filter {
+
+    private final String mFilterString;
+
+    private final Set<Pattern> mPositiveRegexes;
+    private final Set<Pattern> mNegativeRegexes;
+
+    private static final Pattern ASTERISK = Pattern.compile("\\*");
+    private static final Pattern COLON = Pattern.compile(":");
+    private static final Pattern DASH = Pattern.compile("-");
+    private static final Pattern PERIOD = Pattern.compile("\\.");
+
+    /**
+     *  Creates the filter and converts the provided googletest-style filter
+     *  string into positive and negative regexes.
+     */
+    public GtestFilter(String filterString) {
+        mFilterString = filterString;
+        mPositiveRegexes = new HashSet<Pattern>();
+        mNegativeRegexes = new HashSet<Pattern>();
+
+        String[] filterStrings = COLON.split(filterString);
+        for (String f : filterStrings) {
+            if (f.isEmpty()) continue;
+
+            String sanitized = PERIOD.matcher(f).replaceAll("\\\\.");
+            sanitized = ASTERISK.matcher(sanitized).replaceAll(".*");
+            int negIndex = sanitized.indexOf('-');

[kindrik, 2015/08/14 10:15:43]

Hi. Sorry, I have to add a fly in the ointment. But as I see this, I think an
error creeped in there.
Your code first of all splits filterString to parts by colon (':').
Then it checks each part for dash '-'. 
This is fine for filters like this "--gtest_filter=FooTest.*-FooTest.Bar" but
more complicated filters like
"--gtest_filter=FooTest.*-FooTest.test1:FooTest.test2:FooTest.test3" will be
treated incorrectly.
FooTest.test2 and FooTest.test3 will be considered as positive parts. So, our
current blacklisting code is broken for JVM tests becauze it adds only one '-'
per filter.

To find out what is wrong, this code, or may be some other (our) code, I have
read
https://code.google.com/p/googletest/wiki/AdvancedGuide#Running_a_Subset_of_t...
again and again and I see that '-' may be only one in filter string.

It say : "The format of a filter is a ':'-separated list of wildcard patterns
(called the positive patterns) optionally followed by a '-' and another
':'-separated pattern list (called the negative patterns)".
So, as I understand it, the format looks like "test1:test2:test3" or
"test1:test2:test3-test4:test5:test6". This is how I understand it. Where's the
truth?

p.s. so I asked it here to make descision what to fix. Our blacklisting code, or
JVM filtering code.
Thanks.

[jbudorick, 2015/08/14 15:43:56]

Thanks for the report. This is definitely a bug with this code. I've filed
https://code.google.com/p/chromium/issues/detail?id=520997.

+            if (negIndex == 0) {
+                mNegativeRegexes.add(Pattern.compile(sanitized.substring(1)));
+            } else if (negIndex != -1) {
+                String[] c = DASH.split(sanitized, 2);
+                mPositiveRegexes.add(Pattern.compile(c[0]));
+                mNegativeRegexes.add(Pattern.compile(c[1]));
+            } else {
+                mPositiveRegexes.add(Pattern.compile(sanitized));
+            }
+        }
+    }
+
+    /**
+     *  Determines whether or not a test with the provided description should
+     *  run based on the configured positive and negative regexes.
+     *
+     *  A test should run if:
+     *    - it's just a class, OR
+     *    - it doesn't match any of the negative regexes, AND
+     *    - either:
+     *      - there are no configured positive regexes, OR
+     *      - it matches at least one of the positive regexes.
+     */
+    @Override
+    public boolean shouldRun(Description description) {
+        if (description.getMethodName() == null) return true;
+
+        String gtestName = description.getClassName() + "." + description.getMethodName();
+        for (Pattern p : mNegativeRegexes) {
+            if (p.matcher(gtestName).matches()) return false;
+        }
+
+        if (mPositiveRegexes.isEmpty()) return true;
+
+        for (Pattern p : mPositiveRegexes) {
+            if (p.matcher(gtestName).matches()) return true;
+        }
+
+        return false;
+    }
+
+    /**
+     *  Returns a description of this filter.
+     */
+    @Override
+    public String describe() {
+        return "gtest-filter: " + mFilterString;
+    }
+
+}
+