return sb.toString();
        }

        @Override
        public boolean equals(final Object other) {
            if (other == null || !(other instanceof MyToken)) {
                return false;
            }
            final MyToken o = (MyToken) other;
            if (!word.equals(o.word)) {
                return false;
            }
            if (startOffset != o.startOffset) {

        settingsFile << "includeBuild('other-build')"
        file('other-build/settings.gradle') << "rootProject.name = 'other-build'"
        file('other-build/build.gradle') << """
            tasks.register('doSomething') {
                doLast {
                    println 'do something'
                }
            }
        """

        when:
        executeTaskViaTAPI(":other-build:doSomething")

        then:

Sorting is done based on the following rules:

. the installation currently running Gradle is preferred over any other
. JDK installations are preferred over JRE ones
. certain vendors take precedence over others; their ordering (from the highest priority to lowest):
.. ADOPTIUM
.. ADOPTOPENJDK
.. AMAZON
.. APPLE
.. AZUL
.. BELLSOFT
.. GRAAL_VM
.. HEWLETT_PACKARD

                }
            }
        """

        succeeds(":other-build:doSomething", "--content", "do something")
    }

    def "can list tasks from included build"() {
        setup:
        settingsFile << "includeBuild('other-build')"
        file('other-build/settings.gradle') << "rootProject.name = 'other-build'"
        file('other-build/build.gradle') << """
            tasks.register('doSomething') {

        1.1 or earlier of the License, but not also under the terms of a
        Secondary License.

1.6. “Executable Form”

     means any form of the work other than Source Code Form.

1.7. “Larger Work”

     means a work that combines Covered Software with other material, in a separate
     file or files, that is not Covered Software.

1.8. “License”

     means this document.

1.9. “Licensable”

            .store(firstPath, directorySnapshotForPath(firstPath), diffListener)
            .store(secondPath, directorySnapshotForPath(secondPath), diffListener)
            .store("/other/just-checking", directorySnapshotForPath("/other/just-checking"), diffListener)

        expect:
        set.findSnapshot(firstPath).present
        set.findSnapshot(secondPath).present

				return nil, err
			}
			if err := r.Close(); err != nil {
				return nil, err
			}
			b = dbuf
		}
		return b, nil
	}

	// There are many other DWARF sections, but these
	// are the ones the debug/dwarf package uses.
	// Don't bother loading others.
	var dat = map[string][]byte{"abbrev": nil, "info": nil, "str": nil, "line": nil, "ranges": nil}
	for _, s := range f.Sections {
		suffix := dwarfSuffix(s)

  /**
   * Returns the set of values that are contained in both this set and the other.
   *
   * <p>This method should always be used instead of {@link Sets#intersection} for {@link
   * ContiguousSet} instances.
   */
  public abstract ContiguousSet<C> intersection(ContiguousSet<C> other);

  /**
   * Returns a range, closed on both ends, whose endpoints are the minimum and maximum values

        then:
        result.assertTasksExecuted(":other-java:compileJava", ":other-java:processResources", ":other-java:classes", ":other-java:jar", ":java:compileJava", ":java:processResources", ":java:classes", ":java:jar", ":consumer:resolve")
        assertResolveOutput("""
            files: [java.jar, file-dep.jar, other-java.jar, implementation-1.0.jar, runtime-only-1.0.jar]

        repository {
            'org:foo:1.1'()
        }

        buildFile << """
            configurations {
                other
                conf.shouldResolveConsistentlyWith(other)
            }

            dependencies {
                conf 'org:foo:1.0'
                other 'org:foo:1.1'
            }
        """

        when:
        repositoryInteractions {
            'org:foo:1.1' {