namespace mlir::quant::stablehlo {

using ::stablehlo::quantization::CustomQuantizationMethod;
using ::stablehlo::quantization::PresetQuantizationMethod;
using ::stablehlo::quantization::QuantizationComponentSpec;
using ::stablehlo::quantization::QuantizationOptions;
using QuantizationComponent =
    ::stablehlo::quantization::QuantizationComponentSpec_QuantizationComponent;

// tag::module_to_project_substitution[]
configurations.all {
    resolutionStrategy.dependencySubstitution {
        substitute(module("org.utils:api"))
            .using(project(":api")).because("we work with the unreleased development version")
        substitute(module("org.utils:util:2.5")).using(project(":util"))
    }
}
// end::module_to_project_substitution[]
// tag::project_to_module_substitution[]
configurations.all {

		builder.WriteString("JOIN ")
		builder.WriteQuoted(join.Table)

		if len(join.ON.Exprs) > 0 {
			builder.WriteString(" ON ")
			join.ON.Build(builder)
		} else if len(join.Using) > 0 {
			builder.WriteString(" USING (")
			for idx, c := range join.Using {
				if idx > 0 {
					builder.WriteByte(',')
				}
				builder.WriteQuoted(c)
			}
			builder.WriteByte(')')
		}
	}

// tag::configuration[]
// Using the Java API
println System.getenv('ENVIRONMENTAL')

// Using the Gradle API, provides a lazy Provider<String>
println providers.environmentVariable('ENVIRONMENTAL').get()
// end::configuration[]

abstract class PrintValue extends DefaultTask {
    @Input abstract Property<String> getInputValue()
    @TaskAction void action() { println(inputValue.get()) }
}

// tag::execution[]

    return Collections.emptySet();
  }

  protected Collection<Method> suppressForVector() {
    return Collections.emptySet();
  }

  public Test testsForEmptyList() {
    return ListTestSuiteBuilder.using(
            new TestStringListGenerator() {
              @Override
              public List<String> create(String[] elements) {
                return Collections.emptyList();
              }
            })

// tag::system-properties[]
// Using the Java API
println System.getProperty('system')

// Using the Gradle API, provides a lazy Provider<String>
println providers.systemProperty('system').get()
// end::system-properties[]

abstract class PrintValue extends DefaultTask {
    @Input abstract Property<String> getInputValue()
    @TaskAction void action() { println(inputValue.get()) }
}

// tag::system-properties-task-inputs[]

        // Using a string instead of a plain ID here might look strange, but this turned out to be
        // the fastest of several experiments, including:
        //
        //    using ModuleIdentifier (initial implementation)
        //    using ModuleIdentifier through ImmutableModuleIdentifierFactory (for interning)
        //    using a 2-level map (by group, then by name)

        substitute module("org.utils:api") using project(":api") because "we work with the unreleased development version"
        substitute module("org.utils:util:2.5") using project(":util")
    }
}
// end::module_to_project_substitution[]
// tag::project_to_module_substitution[]
configurations.all {
    resolutionStrategy.dependencySubstitution {

#include "tsl/platform/status_matchers.h"

namespace tensorflow {
namespace {

using ::stablehlo::quantization::QuantizationConfig;
using ::stablehlo::quantization::io::CreateTmpDir;
using ::testing::HasSubstr;
using ::tsl::testing::IsOk;
using ::tsl::testing::StatusIs;

// Test cases for `RunQuantization` mainly tests for error cases because testing

                alias(libs.plugins.javaPlugin)
            }
        """

        expect:
        succeeds(":compileJava")
    }

    def "can apply a plugin in both root and sub- project using id and version using version catalog"() {
        given:
        versionCatalogFile """
        [plugins]
        orgExample = "org.example.plugin:1.0.0"
        """
        settingsFile """
            pluginManagement {