revision="1.2"
	/>
	<configurations>
		<conf name="runtime" visibility="public"/>
		<conf name="default" visibility="public" extends="runtime"/>
		<conf name="api" visibility="public"/>
	</configurations>
	<publications>
		<artifact name="projectA" type="jar" ext="jar" conf="*"/>
	</publications>
    <dependencies>
        <dependency org="test" name="projectB" rev="1.5" conf="runtime->default"/>

	paramPath := []byte("path\x00")
	conf := make([]syscall.Iovec, 4)
	conf[0].Base = &paramPath[0]
	conf[0].SetLen(len(paramPath))
	p, err := syscall.BytePtrFromString(root)
	if err != nil {
		t.Fatal(err)
	}
	conf[1].Base = p
	conf[1].SetLen(len(root) + 1)

	paramPersist := []byte("persist\x00")
	conf[2].Base = &paramPersist[0]
	conf[2].SetLen(len(paramPersist))
	conf[3].Base = nil
	conf[3].SetLen(0)

  if (!module) return failure();

  tensorflow::GraphExportConfig confs;
  confs.export_entry_func_to_flib = export_entry_func_to_flib;
  confs.export_original_tf_func_name = export_original_tf_func_name;

  absl::StatusOr<std::unique_ptr<tensorflow::GraphDef>> graphdef_or(
      tensorflow::tf2xla::v2::ConvertMlirToGraphdef(module, confs));
  if (!graphdef_or.status().ok()) {

    }
}
configurations {
    conf
    lockEnabledConf {
        extendsFrom conf
        resolutionStrategy.activateDependencyLocking()
    }
}
dependencies {
    conf 'org:foo:[1.0,)'
    conf 'org:foo:1.1'

    conf 'org:foz:latest.integration'
    conf 'org:foz:1.1'

    conf 'org:bar:1.+'
    conf 'org:bar:1.1'

    conf 'org:baz:+'
    conf 'org:baz:1.1'
}
task check {

		},
		{
			name: "linux_no_nsswitch.conf",
			c: &conf{
				goos: "linux",
			},
			resolv:    defaultResolvConf,
			nss:       &nssConf{err: fs.ErrNotExist},
			hostTests: []nssHostTest{{"google.com", "myhostname", hostLookupFilesDNS}},
		},
		{
			name: "linux_empty_nsswitch.conf",
			c: &conf{
				goos: "linux",
			},
			resolv:    defaultResolvConf,

        'multiple dependency declarations (artifact notation)' | 'bar'        | "conf('org:foo') { artifact { name = 'bar'; type = 'distribution-tgz' } }; conf('org:foo') { artifact { name = 'bar'; type = 'zip' } }"

	case conf.AccountKey == "" && (conf.SPAuth.TenantID == "" || conf.SPAuth.ClientID == "" || conf.SPAuth.ClientSecret == ""):
		return nil, errors.New("no authentication mechanism was provided")
	}

	if conf.Bucket == "" {
		return nil, errors.New("no bucket name was provided")
	}

	if conf.IsSPEnabled() {
		credential, err = newCredentialFromSP(conf)
	} else {

                dependsOn 'org:first:2.0'
            }
        }

        buildFile << """
            dependencies {
                conf(platform('org:platform:1.0'))
                conf 'org:first:1.0'
                conf 'org:second:1.0'
            }
"""
        when:
        repositoryInteractions {
            'org:client:4.1.0' {

}

func Conv2(v interface{}) (string, bool) {
	return conv2[string](v)
}

func conv2[T any](v interface{}) (T, bool) {
	x, ok := v.(T)
	return x, ok
}

func Conv3(v interface{}) string {
	return conv3[string](v)
}

func conv3[T any](v interface{}) T {
	switch v := v.(type) {
	case T:
		return v
	default:
		var z T
		return z
	}
}

type Mystring string

func (Mystring) Foo() {
}

                configurations { conf }
            }

            configurations {
                ${singleProjectConfs.join('\n')}
                single {
                    extendsFrom(${singleProjectConfs.join(',')})
                }
            }

            dependencies {
                conf 'org:foo'
                conf project(path: ':p1', configuration: 'conf')
                ${singleProjectDeps.join('\n')}