buildTypes.each { bt ->
                            flavors.each { f ->
                                String baseName = "${f.capitalize()}${bt.capitalize()}"
                                def implementationConfig = p.configurations.create("implementation$baseName") {
                                    extendsFrom p.configurations.implementation
                                    canBeConsumed = false

        super(names, objects, componentImplementation);
        this.baseName = baseName;

        def jar = GroovyJarFile.parse(new File("$fileName"))

        expect:
        jar != null
        jar.file == new File("$fileName")
        jar.baseName == "groovy"
        jar.version == VersionNumber.parse("$version")
        !jar.groovyAll
        !jar.indy
        jar.dependencyNotation == "$dependencyNotation"

        where:

            }
        }
        """

        when:
        succeeds("help")

        then:
        outputContains("""the action must be tested
${BAZ_GROUP}:${BAZ_NAME}
the action must be tested
${BAZ_GROUP}:${BAZ_NAME}
""")
    }

    def "dependency constraint declared using #expression shows up in related configuration"() {
        given:
        file(dsl.fileNameFor("build")).text = """

  // CHECK: %[[FOO:.*]] = "tf.RestoreV2"(%[[ARG0]], %[[FOO_NAME]], {{.*}})

  // CHECK: %[[BAR_NAME:.*]] = "tf.Const"() <{value = dense<"bar"> : tensor<1x!tf_type.string>}>
  // CHECK: %[[BAR:.*]] = "tf.RestoreV2"(%[[ARG0]], %[[BAR_NAME]], {{.*}})

  // CHECK: return %[[FOO]], %[[BAR]]
  func.return %2#0, %2#1 : tensor<*xf32>, tensor<*xi32>

import java.util.List;

public class DefaultCppLibraryModel extends DefaultCppComponentModel implements InternalCppLibrary {
    public DefaultCppLibraryModel(String name, String baseName, List<DefaultCppBinaryModel> binaries) {
        super(name, baseName, binaries);
    }

    }

    @Override
    protected void configureTaskDefaults(CodeNarc task, String baseName) {
        Configuration configuration = project.getConfigurations().getAt(getConfigurationName());
        configureTaskConventionMapping(configuration, task);
        configureReportsConventionMapping(task, baseName);
        configureToolchains(task);
    }

    @Override
    protected void beforeApply() {

        return this;
    }

    public File map(File sourceFile) {
        final String baseName = FilenameUtils.removeExtension(sourceFile.getName());
        final String uniqueName = generateUniqueNameFor(sourceFile);
        File hashDirectory = new File(outputBaseFolder, uniqueName);
        return new File(hashDirectory, baseName + objectFileNameSuffix);
    }

    protected String generateUniqueNameFor(File sourceFile) {

	StrStr     string  `json:",string"`
	NumberStr  Number  `json:",string"`
}

func TestRoundtripStringTag(t *testing.T) {
	tests := []struct {
		CaseName
		in   StringTag
		want string // empty to just test that we roundtrip
	}{{
		CaseName: Name("AllTypes"),
		in: StringTag{
			BoolStr:    true,
			IntStr:     42,
			UintptrStr: 44,
			StrStr:     "xzbit",
			NumberStr:  "46",
		},
		want: `{

     */
    public LocalDistribution getDistribution(WrapperConfiguration configuration) {
        String baseName = getDistName(configuration.getDistribution());
        String distName = removeExtension(baseName);
        String rootDirName = rootDirName(distName, configuration);