<version>0.2</version>
          </dependency>
          <dependency>
            <groupId>test</groupId>
            <artifactId>b</artifactId>
            <version>0.2</version>
            <scope>compile</scope>
          </dependency>
          <dependency>
            <groupId>test</groupId>
            <artifactId>c</artifactId>
            <version>0.2</version>
            <scope>runtime</scope>

        <groupId>org.apache.maven.its.plugins</groupId>
        <artifactId>maven-it-plugin-dependency-resolution</artifactId>
        <version>2.1-SNAPSHOT</version>
        <configuration>
          <compileClassPath>target/compile.txt</compileClassPath>
        </configuration>
      </plugin>
    </plugins>
  </build>

  private EmptyImmutableSetMultimap() {
    super(ImmutableMap.of(), 0, null);
  }

  /*
   * TODO(b/242884182): Figure out why this helps produce the same class file when we compile most
   * of common.collect a second time with the results of the first compilation on the classpath. Or
   * just back this out once we stop doing that (which we'll do after our internal GWT setup
   * changes).
   */

goarch="$(../bin/go env GOARCH)"

# NOTE: Cannot invoke go command after this point.
# We're about to delete all but the cross-compiled binaries.
cd ..
if [ "$goos" = "$gohostos" -a "$goarch" = "$gohostarch" ]; then
	# cross-compile for local system. nothing to copy.
	# useful if you've bootstrapped yourself but want to
	# prepare a clean toolchain for others.
	true
else
	rm -f bin/go_${goos}_${goarch}_exec
	mv bin/*_*/* bin
	rmdir bin/*_*

  @Suppress("NAME_SHADOWING")
  companion object {
    private val YEAR_PATTERN = Pattern.compile("(\\d{2,4})[^\\d]*")
    private val MONTH_PATTERN =
      Pattern.compile("(?i)(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec).*")
    private val DAY_OF_MONTH_PATTERN = Pattern.compile("(\\d{1,2})[^\\d]*")
    private val TIME_PATTERN = Pattern.compile("(\\d{1,2}):(\\d{1,2}):(\\d{1,2})[^\\d]*")

    private fun domainMatch(

          <type>String</type>
          <description>
            Flags this Mojo as requiring the dependencies in the specified class path to be resolved before it can
            execute: {@code compile}, {@code runtime}, {@code test},
            {@code compile+runtime} (since Maven 3.0) or {@code runtime+system} (since Maven 3.0)
          </description>
        </field>
        <field>
          <name>dependencyResolution</name>

 */
@CacheableTask
abstract class GenerateAutoTestedSamplesTestTask @Inject constructor(@Internal val fileOperations: FileOperations) : DefaultTask() {
    private
    val sampleStart = Pattern.compile("""<pre class=['"]autoTested(.*?)['"].*?>""")

    @get:InputFiles
    @get:PathSensitive(PathSensitivity.RELATIVE)
    abstract val mainSources: ConfigurableFileCollection

    @get:Input

                new File("src/test/projects/lifecycle-dependency-resolver/pom.xml"), new Properties(), true);
        Collection<String> scopesToCollect = null;
        Collection<String> scopesToResolve = Collections.singletonList("compile");
        boolean aggregating = false;

        Set<Artifact> reactorArtifacts = new HashSet<>(3);
        for (MavenProject reactorProject : session.getProjects()) {

import gradlebuild.integrationtests.extension.IntegrationTestExtension
import gradlebuild.integrationtests.setSystemPropertiesOfTestJVM

plugins {
    java
    id("gradlebuild.dependency-modules")
    id("gradlebuild.jvm-compile")
}

extensions.create<IntegrationTestExtension>("integTest").apply {
    generateDefaultAutoTestedSamplesTest.convention(true)
    testJvmXmx.convention("512m")
}

   * has not added {@link AnnotatedType}. That means that we cannot implement that interface in
   * source code in a way that will compile on both Java and Android. If we include the {@code
   * getAnnotatedBounds()} method, then its return type means it won't compile on Android, while if
   * we don't include the method, then the compiler will complain that an abstract method is