file('settings.gradle') << "include 'a', 'a:b', 'a:c', 'a:c:d'"
        file('build.gradle') << '''
task rootTask
project (':a') { description = 'A rocks!' }
'''

        when:
        GradleProject project = withConnection { it.getModel(GradleProject.class) }

        then:
        project.tasks.find { it.name == 'rootTask' }

        project.children.size() == 1
        GradleProject a = project.children[0]

        root.gradleProject.tasks.find { it.name == 'rootTask' && it.path == ':rootTask' && it.project == root.gradleProject }
        !root.gradleProject.tasks.find { it.name == 'implTask' }

        impl.gradleProject.tasks.find { it.name == 'implTask' && it.path == ':impl:implTask' && it.project == impl.gradleProject}
        !impl.gradleProject.tasks.find { it.name == 'rootTask' }
    }

        root.gradleProject.tasks.find { it.name == 'rootTask' && it.path == ':rootTask' && it.project == root.gradleProject }
        !root.gradleProject.tasks.find { it.name == 'implTask' }

        impl.gradleProject.tasks.find { it.name == 'implTask' && it.path == ':impl:implTask' && it.project == impl.gradleProject}
        !impl.gradleProject.tasks.find { it.name == 'rootTask' }
    }

        """

        buildFile << """
            def rootTask = tasks.create("runInWorker", WorkerTask) {
                isolationMode = $isolationMode
            }

            project(":anotherProject") {
                tasks.create("runInWorker2", WorkerTask) {
                    dependsOn rootTask
                    isolationMode = $isolationMode
                }
            }

                "ext.rootProperty = 'root'",
                "ext.sharedProperty = 'ignore me'",
                "ext.property = 'value'",
                "convention.plugins.test = new ConventionBean()",
                "task rootTask",
                "task testTask",
                "class ConventionBean { def getConventionProperty() { 'convention' } }"
        )
        file("child/build.gradle").writelns(
                "ext.childProperty = 'child'",

        def a = createChildProject(project, "a")

        [project, a].each { it.task "foo"; it.task "bar" }

        when:
        def rootTasks = project.getAllTasks(true)
        def aTasks = a.getAllTasks(true)

        then:
        rootTasks.size() == 2

	return
}

// Get returns the current value of key.
func (s smtLedger) Get(key string) (result string, err error) {
	return s.GetPreviousValue(s.RootHash(), key)
}

// RootHash represents the hash of the current state of the ledger.
func (s smtLedger) RootHash() string {
	return base64.StdEncoding.EncodeToString(s.tree.Root())
}

func coerceKeyToHashLen(val string) []byte {
	hasher := murmur3.New64()

	l := smtLedger{tree: newSMT(hasher, nil, time.Minute)}
	resultHashes := map[string]bool{}
	l.Put("foo", "bar")
	firstHash := l.RootHash()

	resultHashes[l.RootHash()] = true
	l.Put("foo", "baz")
	resultHashes[l.RootHash()] = true
	l.Put("second", "value")
	resultHashes[l.RootHash()] = true
	getResult, err := l.Get("foo")
	assert.NoError(t, err)
	assert.Equal(t, getResult, "baz")
	getResult, err = l.Get("second")

		},
		"secure with roots": {
			TLSConfig: &tls.Config{InsecureSkipVerify: false, RootCAs: roots},
		},
		"secure with mismatched server": {
			TLSConfig:   &tls.Config{InsecureSkipVerify: false, RootCAs: roots, ServerName: "bogus.com"},
			ExpectError: "not bogus.com",
		},
		"secure with matched server": {
			TLSConfig: &tls.Config{InsecureSkipVerify: false, RootCAs: roots, ServerName: "example.com"},
		},

		"insecure, custom dial": {

	return func(args *OperatorDNS) {
		args.username = username
		args.password = password
	}
}

// RootCAs - add custom trust certs pool
func RootCAs(certPool *x509.CertPool) OperatorOption {
	return func(args *OperatorDNS) {
		args.rootCAs = certPool
	}
}

// NewOperatorDNS - initialize a new K8S Operator DNS set/unset values.