* #listIterator(int)}. If you override {@link #listIterator(int)}, you may wish to override
   * {@link #lastIndexOf} to forward to this implementation.
   *
   * @since 7.0
   */
  protected int standardLastIndexOf(@CheckForNull Object element) {
    return Lists.lastIndexOfImpl(this, element);
  }

  /**

description = "Provides plugins that configures the root Gradle project"

dependencies {
    implementation("gradlebuild:basics")

    implementation(project(":idea"))
    implementation(project(":profiling"))

    implementation(project(":cleanup")) {
        because("The CachesCleaner service is shared and needs to be on the root classpath")
    }

    implementation("com.autonomousapps:dependency-analysis-gradle-plugin")

            @Override
            public void visitImplementation(Class<?> implementation) {
                workClass.set(GeneratedSubclasses.unpack(implementation));
            }

            @Override
            public void visitImplementation(ImplementationSnapshot implementation) {
            }
        });

// tag::exclude-transitive-dependencies-1[]
dependencies {
    implementation('commons-beanutils:commons-beanutils:1.9.4') {
        exclude group: 'commons-collections', module: 'commons-collections'
    }
}
// end::exclude-transitive-dependencies-1[]
} else if (project.hasProperty('sample2')) {
// tag::exclude-transitive-dependencies-2[]
    dependencies {
        implementation('commons-beanutils:commons-beanutils:1.9.4') {

        e.message == "No implementation class specified for plugin 'noImpl' in $url."

        when:
        pluginRegistry.lookup(DefaultPluginId.of("noImpl"))

        then:
        e = thrown()
        e.message == "No implementation class specified for plugin 'noImpl' in $url."
    }

    def "can locate a plugin implementation that is neither imperative or rule source"() {

    Configuration implementation = Stub(ConfigurationInternal)

    def "has implementation dependencies"() {
        given:
        def binary = new TestBinary("binary", project.objects, implementation)

        expect:
        binary.implementationDependencies == project.configurations.binaryImplementation
        binary.implementationDependencies.extendsFrom == [implementation] as Set
    }

        then:
        def ex = thrown IllegalStateException
        ex.message == "Cannot register implementation for type '${fullyQualifiedNameOf(ThingSpec)}' because an implementation for this type was already registered by test rule"
    }

    def "fails when asking for implementation info for a non-managed type"() {
        when:
        instanceFactory.getManagedSubtypeImplementationInfo(ModelType.of(ThingSpec))

}

// RootFsInfo is a fake implementation of Interface.RootFsInfo.
func (c *Fake) RootFsInfo() (cadvisorapiv2.FsInfo, error) {
	return cadvisorapiv2.FsInfo{}, nil
}

// ContainerFsInfo is a fake implementation of Interface.ContainerFsInfo.
func (c *Fake) ContainerFsInfo() (cadvisorapiv2.FsInfo, error) {
	return cadvisorapiv2.FsInfo{}, nil
}

// GetDirFsInfo is a fake implementation of Interface.GetDirFsInfo.

dependencies {
    api(project(":declarative-dsl-tooling-models"))

    api(libs.kotlinCompilerEmbeddable)
    api(libs.kotlinStdlib)

    implementation(project(":declarative-dsl-api"))
    implementation(libs.kotlinReflect)
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-core:1.6.2")
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.2")

    testImplementation(libs.futureKotlin("test-junit5"))

// license that can be found in the LICENSE file.

package p

type Exported interface {
	private()
}

type Implementation struct{}

func (p *Implementation) private() { println("p.Implementation.private()") }