expect:
        OperatingSystem.current().name == 'GradleOS 1.0' || !resetStateSuccess
    }

    def "uses os.version property to determine OS version"() {
        given:
        System.properties['os.version'] = '42'
        boolean resetStateSuccess = resetOperatingSystemClassStaticFields()

        expect:

        def conflict = container.newElement('a', [], null)

        expect:
        conflict == null
        container.size == 0
    }

    def "contains few unconflicted elements"() {
        container.newElement("a", [1], null)
        container.newElement("b", [1], null)
        container.newElement("c", [1], "d")
        expect:
        container.size == 0
    }

    def "contains conflicting element"() {

	m := NewMessage(mt, nil, "Feta")

	g.Expect(m.Unstructured(true)).To(Not(HaveKey("origin")))
	g.Expect(m.Unstructured(false)).To(Not(HaveKey("origin")))

	m = NewMessage(mt, &resource.Instance{Origin: testOrigin{name: "toppings/cheese"}}, "Feta")

	g.Expect(m.Unstructured(true)).To((HaveKey("origin")))
	g.Expect(m.Unstructured(false)).To(Not(HaveKey("origin")))
}

		}
	}
}

func testSubmatchIndices(test *FindTest, n int, expect, result []int, t *testing.T) {
	if len(expect) != len(result) {
		t.Errorf("match %d: expected %d matches; got %d: %s", n, len(expect)/2, len(result)/2, test)
		return
	}
	for k, e := range expect {
		if e != result[k] {
			t.Errorf("match %d: submatch error: expected %v got %v: %s", n, expect, result, test)
		}
	}
}

		name   string
		pod    *v1.Pod
		expect []*v1.Service
	}{
		{
			name:   "GetPodServices for pod-0",
			pod:    pods[0],
			expect: []*v1.Service{services[0]},
		},
		{
			name:   "GetPodServices for pod-1",
			pod:    pods[1],
			expect: []*v1.Service{services[1]},
		},
		{
			name:   "GetPodServices for pod-2",
			pod:    pods[2],
			expect: []*v1.Service{services[2]},
		},
		{

		toleration      Toleration
		taint           Taint
		expectTolerated bool
	}{
		{
			description: "toleration and taint have the same key and effect, and operator is Exists, and taint has no value, expect tolerated",
			toleration: Toleration{
				Key:      "foo",
				Operator: TolerationOpExists,
				Effect:   TaintEffectNoSchedule,
			},
			taint: Taint{
				Key:    "foo",
				Effect: TaintEffectNoSchedule,

    def convertsEmptyArgs() {
        expect:
        checkConversion([])
    }

    def convertsDebugLevel() {
        expectedConfig.logLevel = LogLevel.DEBUG

        expect:
        checkConversion(['-d'])
        checkConversion(['--debug'])
    }

    def convertsInfoLevel() {
        expectedConfig.logLevel = LogLevel.INFO

        expect:
        checkConversion(['-i'])

        def relpath = relpath(file)

        expect:
        def path = factory.path(file)
        path.url == "file://$relpath"
        path.relPath == relpath
    }

    def usesTheClosestAncestorRootDirForAFileUnderMultipleRootDirs() {
        factory.addPathVariable('ROOT_DIR', tmpDir.testDirectory)
        factory.addPathVariable('SUB_DIR', tmpDir.file('sub'))

        expect:

    }

    def "ignores system include file that does not exist"() {
        expect:
        def result = resolve(include('<test.h>'))
        result.complete
        result.files.empty
    }

    def "ignores quoted include file that does not exist"() {
        expect:
        def result = resolve(include('"test.h"'))
        result.complete
        result.files.empty
    }

            .withClassLoaderStructure(new HierarchicalClassLoaderStructure(spec1).withChild(spec2))
            .keepAliveMode(KeepAliveMode.SESSION)
            .build()

        expect:
        settings.isCompatibleWith(settings)
    }

    def "is compatible with same settings"() {
        def spec1 = Mock(ClassLoaderSpec)
        def spec2 = Mock(ClassLoaderSpec)