%1:2 = stablehlo.custom_call @stablehlo.composite(%arg0, %arg1) {called_computations = [@foo.impl], composite.backend_config = {attributes = {bar = 500 : i64}, name = "odml.foo"}} : (tensor<1xf32>, tensor<2xf32>) -> (tensor<2xf32>, tensor<1xf32>)
    return
  }
  // CHECK-LABEL: func private @foo.impl

        then:
        1 * pluginManager.apply(impl)
        1 * pluginRegistry.lookup(DefaultPluginId.of("foo")) >> impl
    }

    def "can resolve qualified"() {
        when:
        def request = request("org.gradle.foo")
        def result = resolver.resolve(request)
        result.getFound(request).applyTo(pluginManager)

        then:
        1 * pluginManager.apply(impl)

    apply plugin: 'java'
    apply plugin: 'eclipse'
}

project(':api') {
    eclipse.project.name = 'gradle-api'
}

project(':impl') {
    eclipse.project.name = 'gradle-impl'
}
'''
        createDirs("api", "impl")
        file('settings.gradle').text = "include 'api', 'impl'"

        when:
        EclipseProject eclipseProject = loadToolingModel(EclipseProject)

        then:

//
// TODO(fengliuai): supports a configurable accumulator bit width.
template <int Bias, int... Operands>
class AccumulatorUniformScale {
 public:
  template <typename ConcreteType>
  class Impl
      : public QuantizationSpecTraitBase<
            ConcreteType, AccumulatorUniformScale<Bias, Operands...>::Impl> {
   public:

        file('build.gradle').text = """
subprojects {
    apply plugin: 'java'
}

project(':impl') {
    apply plugin: 'idea'

    dependencies {
        ${implementationConfiguration} project(':api')
    }
}
"""
        file('settings.gradle').text = "include 'api', 'impl'"

        when:
        IdeaProject project = withConnection { connection -> connection.getModel(IdeaProject.class) }

        addClass(cl, impl)

        expect:
        detector.cache.size() == 1

        when:
        cl.clearCache()

        then:
        ConcurrentTestUtil.poll(10) {
            System.gc()
            detector.cache.cleanUp()
            detector.cache.size() == 0
        }

        where:
        impl << [
                "class SomeThing {}",

import org.gradle.internal.fingerprint.FingerprintingStrategy;
import org.gradle.internal.fingerprint.impl.AbsolutePathFingerprintingStrategy;
import org.gradle.internal.fingerprint.impl.IgnoredPathFingerprintingStrategy;
import org.gradle.internal.fingerprint.impl.NameOnlyFingerprintingStrategy;
import org.gradle.internal.fingerprint.impl.RelativePathFingerprintingStrategy;

import java.util.SortedMap;

 * limitations under the License.
 */

package org.gradle.internal.enterprise.impl;

import org.gradle.internal.enterprise.impl.legacy.DefaultBuildScanBuildStartedTime;
import org.gradle.internal.enterprise.impl.legacy.DefaultBuildScanClock;
import org.gradle.internal.enterprise.impl.legacy.DefaultBuildScanScopeIds;
import org.gradle.internal.enterprise.impl.legacy.LegacyGradleEnterprisePluginCheckInService;

import org.gradle.internal.snapshot.impl.DirectorySnapshotterStatistics;
import org.gradle.internal.vfs.FileSystemAccess;
import org.gradle.internal.vfs.VirtualFileSystem;
import org.gradle.internal.vfs.impl.DefaultFileSystemAccess;
import org.gradle.internal.vfs.impl.DefaultSnapshotHierarchy;
import org.gradle.internal.watch.registry.FileWatcherRegistryFactory;
import org.gradle.internal.watch.registry.impl.DarwinFileWatcherRegistryFactory;

int64_t AddRaw(int64_t a, int64_t b) { return a + b; }

}  // namespace

// Add numbers in a loop by calling a callable.
void CallFunctions(::testing::benchmark::State& state) {
  Integer sum(0);
  Callable callable((impl::TaggedValue(impl::Func(AddTagged))));
  *callable.Call<Integer>(sum, Integer(30));
  size_t i = 0;
  for (auto dummy : state) {
    sum = *callable.Call<Integer>(sum, Integer(i));
    i++;
  }
}