3.x: remove test from testXXX method names, create a validator (#6525)

* Add a check to verify there are no methods with the prefix "test" in the name

* Automatically rename methods "testXXX" to "xxx"

* Do not remove comments

* Run check on CI, but do not change the files

* Do not automatically rename methods for now

* Ignore test prefix check for now

Author: maksim-m

src/test/java/io/reactivex/validators/TestPrefixInMethodName.java

@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) 2016-present, RxJava Contributors.
+ *
+ * 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 io.reactivex.validators;
+
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.io.*;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Queue;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Check verifying there are no methods with the prefix "test" in the name
+ */
+public class TestPrefixInMethodName {
+
+    private static final String pattern = "void\\s+test[a-zA-Z0-9]";
+    private static final String replacement = "void ";
+
+    @Test
+    @Ignore
+    public void checkAndUpdateTestMethodNames() throws Exception {
+        File f = MaybeNo2Dot0Since.findSource("Flowable");
+        if (f == null) {
+            System.out.println("Unable to find sources of RxJava");
+            return;
+        }
+
+        Queue<File> dirs = new ArrayDeque<File>();
+
+        StringBuilder fail = new StringBuilder();
+        fail.append("The following code pattern was found: ").append(pattern).append("\n");
+        fail.append("Refresh and re-run tests!\n\n");
+
+        File parent = f.getParentFile();
+
+        dirs.offer(new File(parent.getAbsolutePath().replace('\\', '/')));
+        dirs.offer(new File(parent.getAbsolutePath().replace('\\', '/').replace("src/main/java", "src/test/java")));
+
+        Pattern p = Pattern.compile(pattern);
+
+        int total = 0;
+
+        while (!dirs.isEmpty()) {
+            f = dirs.poll();
+
+            File[] list = f.listFiles();
+            if (list != null && list.length != 0) {
+
+                for (File u : list) {
+                    if (u.isDirectory()) {
+                        dirs.offer(u);
+                    } else {
+                        String fname = u.getName();
+                        if (fname.endsWith(".java")) {
+
+                            int lineNum = 0;
+                            List<String> lines = new ArrayList<String>();
+                            BufferedReader in = new BufferedReader(new FileReader(u));
+                            boolean found = false;
+                            try {
+                                for (; ; ) {
+                                    String line = in.readLine();
+                                    if (line == null) {
+                                        break;
+                                    }
+                                    lineNum++;
+
+                                    Matcher matcher = p.matcher(line);
+                                    if (!line.startsWith("//") && !line.startsWith("*") && matcher.find()) {
+                                        found = true;
+                                        fail
+                                                .append(fname)
+                                                .append("#L").append(lineNum)
+                                                .append("    ").append(line)
+                                                .append("\n");
+                                        total++;
+
+                                        int methodNameStartIndex = matcher.end() - 1;
+                                        char firstChar = Character.toLowerCase(line.charAt(methodNameStartIndex));
+
+                                        String newLine = matcher.replaceAll(replacement + firstChar);
+
+                                        lines.add(newLine);
+                                    } else {
+                                        lines.add(line);
+                                    }
+
+                                }
+                            } finally {
+                                in.close();
+                            }
+
+                            /*if (found && System.getenv("CI") == null) {
+                                PrintWriter w = new PrintWriter(new FileWriter(u));
+
+                                try {
+                                    for (String s : lines) {
+                                        w.println(s);
+                                    }
+                                } finally {
+                                    w.close();
+                                }
+                            }*/
+                        }
+                    }
+                }
+            }
+        }
+        if (total != 0) {
+            fail.append("Found ")
+                    .append(total)
+                    .append(" instances");
+            System.out.println(fail);
+            throw new AssertionError(fail.toString());
+        }
+    }
+}