x   Expr
	out string
}{
	{
		x:   tag("abc"),
		out: "abc",
	},
	{
		x:   not(tag("abc")),
		out: "!abc",
	},
	{
		x:   not(and(tag("abc"), tag("def"))),
		out: "!(abc && def)",
	},
	{
		x:   and(tag("abc"), or(tag("def"), tag("ghi"))),
		out: "abc && (def || ghi)",
	},
	{
		x:   or(and(tag("abc"), tag("def")), tag("ghi")),
		out: "(abc && def) || ghi",
	},
}

		wantNamespace string
	}{
		{
			name:          "foo-abc.istio-system",
			wantPodName:   "foo-abc",
			wantNamespace: "istio-system",
		},
		{
			name:          "foo-abc",
			wantPodName:   "foo-abc",
			wantNamespace: "test",
		},
		{
			name:          "Deployment/foo.istio-system",
			wantPodName:   "foo-abc",
			wantNamespace: "istio-system",
		},
		{

	}
}

var cutTests = []struct {
	s, sep        string
	before, after string
	found         bool
}{
	{"abc", "b", "a", "c", true},
	{"abc", "a", "", "bc", true},
	{"abc", "c", "ab", "", true},
	{"abc", "abc", "", "", true},
	{"abc", "", "", "abc", true},
	{"abc", "d", "abc", "", false},
	{"", "d", "", "", false},
	{"", "", "", "", true},
}

func TestCut(t *testing.T) {

                super.connect(snk)
                write(TextUtil.toPlatformLineSeparators("abc\n123").bytes)
                close()
            }
        })

        when:
        run "echo"

        then:
        output.contains("[abc][123]")
    }

    def "task can read stdin when stdin has unbounded length"() {
        given:
        buildFile << '''
task echo {

				_ = set1000.Contains("456")
				_ = set1000.Contains("abc")
			}
		})
		b.Run("Contains/100", func(b *testing.B) {
			for range b.N {
				_ = set100.Contains("45")
				_ = set100.Contains("abc")
			}
		})
		b.Run("Contains/2", func(b *testing.B) {
			for range b.N {
				_ = set2.Contains("1")
				_ = set2.Contains("abc")
			}
		})
	})
	b.Run("SmallSet", func(b *testing.B) {

          ),
        body = "ABC.1",
      ),
    )
    server.enqueue(
      MockResponse(
        headers =
          headersOf(
            "Last-Modified",
            formatDate(-1, TimeUnit.HOURS)!!,
            "Expires",
            formatDate(1, TimeUnit.HOURS)!!,
          ),
        body = "ABC.2",
      ),
    )
    client =
      client.newBuilder()

    }

    void "can declare origin of a checksum"() {
        declareChecksum("org:foo:1.0", "sha1", "abc", "from test")
        declareChecksum("org:bar:1.0", "sha1", "abc", "from test")
        declareChecksum("org:bar:1.0", "md5", "abc", "other")

        when:
        serialize()

        then:
        contents == """<?xml version="1.0" encoding="UTF-8"?>
<verification-metadata>

    types = listOf(Abc::class, C::class, D::class),
    externalFunctions = listOf(::newD),
    defaultImports = listOf(DefaultFqName("com.example", "newD"))
)


object SimpleAnalysisDemo {
    @JvmStatic
    fun main(args: Array<String>) {
        printResolutionResults(
            schema.resolve(
                """
                    val myB = b()

                    a = myB

				RestartPolicy: api.RestartPolicyAlways,
				DNSPolicy:     api.DNSClusterFirst,
				Containers:    []api.Container{{Name: "abc", Image: "image", ImagePullPolicy: "IfNotPresent", TerminationMessagePolicy: api.TerminationMessageReadFile}},
			},
		},
	}
	rc := &api.ReplicationController{
		ObjectMeta: metav1.ObjectMeta{Name: "abc", Namespace: metav1.NamespaceDefault},
		Spec: api.ReplicationControllerSpec{
			Selector: validSelector,

        def initialValue = toMutable(["abc"])
        property.set(initialValue)
        assertValueIs(["abc"])
        initialValue.add("added")
        assertValueIs(["abc", "added"])
    }

    def "queries underlying provider for every call to get()"() {
        def provider = Stub(ProviderInternal)
        provider.type >> List
        provider.calculateValue(_) >>> [["123"], ["abc"]].collect { ValueSupplier.Value.of(it) }