testing against gradle 3.3

Author: dcendents

build.gradle

@@ -16,7 +16,7 @@ repositories {
 }
 
 ext {
-	gradleVersions = '3.0,3.1,3.2,3.2.1'
+	gradleVersions = '3.0,3.1,3.2,3.2.1,3.3'
 	androidGradleBuildVersion = '2.2.0-beta1'
 	androidCompileSdkVersion = 'android-24'
 	androidBuildToolsVersion = '24.0.0'
@@ -223,7 +223,7 @@ jacocoTestReport.dependsOn test
 check.dependsOn jacocoTestReport
 
 task wrapper(type: Wrapper) {
-    gradleVersion = '3.2.1'
+    gradleVersion = '3.3'
     distributionUrl = "https://services.gradle.org/distributions/gradle-${gradleVersion}-all.zip"
 }
 

gradle/wrapper/gradle-wrapper.jar

@@ -1,6 +1,6 @@
-#Tue Nov 22 21:11:44 EST 2016
+#Tue Jan 03 21:54:54 EST 2017
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.2.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-3.3-all.zip

gradle/wrapper/gradle-wrapper.properties

@@ -56,7 +56,7 @@ public static FileResolver resolver(File baseDir) {
     }
 
     public static DirectoryFileTreeFactory directoryFileTreeFactory() {
-        return new DefaultDirectoryFileTreeFactory();
+        return new DefaultDirectoryFileTreeFactory(getPatternSetFactory(), fileSystem());
     }
 
     public static FileCollectionFactory fileCollectionFactory() {

src/test/core/src/testFixtures/groovy/org/gradle/api/internal/file/TestFiles.java

@@ -25,6 +25,7 @@ import org.gradle.api.internal.AsmBackedClassGenerator
 import org.gradle.api.internal.project.ProjectInternal
 import org.gradle.api.internal.project.taskfactory.AnnotationProcessingTaskFactory
 import org.gradle.api.internal.project.taskfactory.DefaultTaskClassInfoStore
+import org.gradle.api.internal.project.taskfactory.DefaultTaskClassValidatorExtractor
 import org.gradle.api.internal.project.taskfactory.ITaskFactory
 import org.gradle.api.internal.project.taskfactory.TaskFactory
 import org.gradle.api.internal.tasks.TaskExecuter
@@ -44,7 +45,8 @@ import static org.junit.Assert.assertFalse
 public abstract class AbstractSpockTaskTest extends AbstractProjectBuilderSpec {
     public static final String TEST_TASK_NAME = "taskname"
 
-    private static final ITaskFactory TASK_FACTORY = new AnnotationProcessingTaskFactory(new DefaultTaskClassInfoStore(), new TaskFactory(new AsmBackedClassGenerator()))
+    def taskClassInfoStore = new DefaultTaskClassInfoStore(new DefaultTaskClassValidatorExtractor())
+    private final ITaskFactory taskFactory = new AnnotationProcessingTaskFactory(taskClassInfoStore, new TaskFactory(new AsmBackedClassGenerator()))
 
     public abstract AbstractTask getTask();
 
@@ -57,7 +59,7 @@ public abstract class AbstractSpockTaskTest extends AbstractProjectBuilderSpec {
     }
 
     public <T extends AbstractTask> T createTask(Class<T> type, Project project, String name) {
-        Task task = TASK_FACTORY.createChild(project, DirectInstantiator.INSTANCE).createTask(
+        Task task = taskFactory.createChild(project, DirectInstantiator.INSTANCE).createTask(
                 GUtil.map(Task.TASK_TYPE, type,
                         Task.TASK_NAME, name))
         assert type.isAssignableFrom(task.getClass())

src/test/core/src/testFixtures/groovy/org/gradle/api/tasks/AbstractSpockTaskTest.groovy

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * 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 org.gradle.internal.progress;
+
+import org.gradle.api.Action;
+import org.gradle.api.Nullable;
+import org.gradle.api.Transformer;
+import org.gradle.internal.operations.BuildOperationContext;
+
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/**
+ * A BuildOperationExecutor for tests.
+ * Simply execute given operations, does not support current/parent operations.
+ */
+public class TestBuildOperationExecutor implements BuildOperationExecutor {
+    public final List<BuildOperationDetails> operations = new CopyOnWriteArrayList<BuildOperationDetails>();
+
+    @Override
+    public Operation getCurrentOperation() {
+        return new Operation() {
+            @Override
+            public Object getId() {
+                return "current";
+            }
+        };
+    }
+
+    @Override
+    public <T> T run(String displayName, Transformer<T, ? super BuildOperationContext> factory) {
+        operations.add(BuildOperationDetails.displayName(displayName).build());
+        return factory.transform(new TestBuildOperationContext());
+    }
+
+    @Override
+    public <T> T run(BuildOperationDetails operationDetails, Transformer<T, ? super BuildOperationContext> factory) {
+        operations.add(operationDetails);
+        return factory.transform(new TestBuildOperationContext());
+    }
+
+    @Override
+    public void run(String displayName, Action<? super BuildOperationContext> action) {
+        operations.add(BuildOperationDetails.displayName(displayName).build());
+        action.execute(new TestBuildOperationContext());
+    }
+
+    @Override
+    public void run(BuildOperationDetails operationDetails, Action<? super BuildOperationContext> action) {
+        operations.add(operationDetails);
+        action.execute(new TestBuildOperationContext());
+    }
+
+    private static class TestBuildOperationContext implements BuildOperationContext {
+        @Override
+        public void failed(@Nullable Throwable failure) {
+        }
+    }
+}

src/test/core/src/testFixtures/groovy/org/gradle/internal/progress/TestBuildOperationExecutor.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * 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 org.gradle.util
+
+import com.google.common.base.Splitter
+
+class BinaryDiffUtils {
+    public static List<String> toHexStrings(byte[] bytes, int bytesPerLine = 16) {
+        def sw = new StringWriter()
+        bytes.encodeHex().writeTo(sw)
+        return Splitter.fixedLength(bytesPerLine * 2).split(sw.toString()).collect { line ->
+            Splitter.fixedLength(2).split(line).join(" ")
+        }
+    }
+
+    public static int levenshteinDistance(byte[] lhs, byte[] rhs) {
+        int len0 = lhs.length + 1;
+        int len1 = rhs.length + 1;
+
+        // the array of distances
+        int[] cost = new int[len0];
+        int[] newcost = new int[len0];
+
+        // initial cost of skipping prefix in byte[] s0
+        for (int i = 0; i < len0; i++) {
+            cost[i] = i
+        }
+
+        // dynamically computing the array of distances
+
+        // transformation cost for each letter in s1
+        for (int j = 1; j < len1; j++) {
+            // initial cost of skipping prefix in byte[] s1
+            newcost[0] = j;
+
+            // transformation cost for each letter in s0
+            for (int i = 1; i < len0; i++) {
+                // matching current letters in both strings
+                int match = (lhs[i - 1] == rhs[j - 1]) ? 0 : 1;
+
+                // computing cost for each transformation
+                int costReplace = cost[i - 1] + match;
+                int costInsert = cost[i] + 1;
+                int costDelete = newcost[i - 1] + 1;
+
+                // keep minimum cost
+                newcost[i] = Math.min(Math.min(costInsert, costDelete), costReplace);
+            }
+
+            // swap cost/newcost arrays
+            int[] swap = cost; cost = newcost; newcost = swap;
+        }
+
+        // the distance is the cost for transforming all letters in both strings
+        return cost[len0 - 1];
+    }
+}

src/test/core/src/testFixtures/groovy/org/gradle/util/BinaryDiffUtils.groovy

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * 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 org.gradle.util
+
+import java.util.jar.JarOutputStream
+import java.util.zip.ZipEntry
+
+class JarUtils {
+    static def jarWithContents(Map<String, String> contents) {
+        def out = new ByteArrayOutputStream()
+        def jarOut = new JarOutputStream(out)
+        try {
+            contents.each { file, fileContents ->
+                def zipEntry = new ZipEntry(file)
+                zipEntry.setTime(0)
+                jarOut.putNextEntry(zipEntry)
+                jarOut << fileContents
+            }
+        } finally {
+            jarOut.close()
+        }
+        return out.toByteArray()
+    }
+}

src/test/core/src/testFixtures/groovy/org/gradle/util/JarUtils.groovy

@@ -16,7 +16,7 @@
 
 package org.gradle.util;
 
-import org.gradle.internal.TimeProvider;
+import org.gradle.internal.time.TimeProvider;
 
 public class MockTimeProvider implements TimeProvider {
 
@@ -40,4 +40,10 @@ public long getCurrentTime() {
         current += 10L;
         return current;
     }
+
+    /** Increments the time by 10ms and returns it. */
+    @Override
+    public long getCurrentTimeForDuration() {
+        return getCurrentTime();
+    }
 }

src/test/core/src/testFixtures/groovy/org/gradle/util/MockTimeProvider.java

@@ -24,10 +24,20 @@
 import org.gradle.internal.concurrent.ExecutorFactory;
 import org.hamcrest.Matcher;
 import org.junit.After;
+import org.junit.rules.ExternalResource;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Date;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.AbstractExecutorService;
 import java.util.concurrent.CopyOnWriteArraySet;
 import java.util.concurrent.ExecutorService;
@@ -37,7 +47,7 @@
 import java.util.concurrent.locks.ReentrantLock;
 
 /**
- * <p>A base class for testing concurrent code.</p>
+ * <p>A rule for testing concurrent code.</p>
  *
  * <p>Provides several ways to start and manage threads. You can use the {@link #start(groovy.lang.Closure)} or {@link
  * #run(groovy.lang.Closure)} methods to execute test code in other threads. You can use {@link #waitForAll()} to wait
@@ -50,8 +60,8 @@
  * <p>You can use {@link #syncAt(int)} and {@link #expectBlocksUntil(int, groovy.lang.Closure)} to synchronise between
  * test threads.</p>
  */
-public class MultithreadedTestCase {
-    private static final Logger LOGGER = LoggerFactory.getLogger(MultithreadedTestCase.class);
+public class MultithreadedTestRule extends ExternalResource {
+    private static final Logger LOGGER = LoggerFactory.getLogger(MultithreadedTestRule.class);
     private static final int MAX_WAIT_TIME = 5000;
     private ExecutorImpl executor;
     private final Lock lock = new ReentrantLock();
@@ -257,6 +267,11 @@ public void waitForStop() {
         waitForAll();
     }
 
+    @Override
+    protected void after() {
+        waitForStop();
+    }
+
     /**
      * Returns the meta-info for the given clock tick.
      */