xdstest.ValidateRoutes(t, routes)
		g.Expect(err).NotTo(HaveOccurred())
		g.Expect(len(routes)).To(Equal(3))
		g.Expect(routes[0].GetMatch().GetPrefix()).To(Equal("/foo"))
		g.Expect(routes[0].StatPrefix).To(Equal("foo"))
		g.Expect(routes[1].GetMatch().GetPrefix()).To(Equal("/baz"))
		g.Expect(routes[1].StatPrefix).To(Equal(""))
		g.Expect(routes[2].GetMatch().GetPrefix()).To(Equal("/bar"))

			},
			expect: true,
		},
		"allowPrivilegeEscalation true": {
			sc: &v1.SecurityContext{
				AllowPrivilegeEscalation: &ptrue,
			},
			expect: false,
		},
	}

	for k, v := range tests {
		actual := AddNoNewPrivileges(v.sc)
		if actual != v.expect {
			t.Errorf("%s failed, expected %t but received %t", k, v.expect, actual)
		}
	}
}

func TestConvertToRuntimeMaskedPaths(t *testing.T) {

	mockStatsProvider.EXPECT().GetNode().Return(node, nil)
	mockStatsProvider.EXPECT().GetNodeConfig().Return(nodeConfig)
	mockStatsProvider.EXPECT().GetPodCgroupRoot().Return(cgroupRoot)
	mockStatsProvider.EXPECT().ListPodStats(ctx).Return(podStats, nil).AnyTimes()
	mockStatsProvider.EXPECT().ListPodStatsAndUpdateCPUNanoCoreUsage(ctx).Return(podStats, nil)

        def bean = create(BeanWithAbstractProperty)

        expect:
        bean.name == null
        bean.setName("name")
        bean.name == "name"
    }

    def canUnpackAndRecreateAbstractClassWithAbstractPropertyGetterAndSetter() {
        def bean = create(BeanWithAbstractProperty)

        expect:
        bean instanceof Managed
        bean.publicType() == BeanWithAbstractProperty

    def "empty snapshots (#strategy.class.simpleName)"() {
        expect:
        changes(strategy,
            [:],
            [:]
        ) as List == []

        where:
        strategy << ALL_STRATEGIES
    }

    def "trivial addition (#strategy.class.simpleName)"() {
        expect:
        changes(strategy,
            ["new/one": fingerprint("one")],
            [:]

man-shifts.dyn.expect", "src/compress/flate/testdata/huffman-shifts.dyn.expect-noinput", "src/compress/flate/testdata/huffman-shifts.golden", "src/compress/flate/testdata/huffman-shifts.in", "src/compress/flate/testdata/huffman-shifts.wb.expect", "src/compress/flate/testdata/huffman-shifts.wb.expect-noinput", "src/compress/flate/testdata/huffman-text-shift.dyn.expect", "src/compress/flate/testdata/huffman-text-shift.dyn.expect-noinput", "src/compress/flate/testdata/huffman-text-shift.golden", "s...

                "1-beta",
                "1.0-\n"
        ]
    }

    def "current version has non-null parts"() {
        expect:
        version.version
        version.nextMajorVersion
        version.baseVersion
    }

    def 'can parse commitId from commit version'() {
        expect:
        GradleVersion.version('5.1-commit-123abc').commitId == '123abc'
    }

				"active": true,
			},
			expect: clause.Values{
				Columns: []clause.Column{{Name: "active"}},
				Values:  [][]interface{}{{true}},
			},
		},
	}

	for _, tc := range testCase {
		t.Run(tc.name, func(t *testing.T) {
			actual := ConvertMapToValuesForCreate(&gorm.Statement{}, tc.input)
			if !reflect.DeepEqual(actual, tc.expect) {
				t.Errorf("expect %v got %v", tc.expect, actual)
			}
		})
	}
}

                assert graph.hasTask(':b')
                assert graph.hasTask(b)
                assert graph.allTasks == [b, a]
                notified = true
            }
        """
        expect:
        2.times {
            succeeds "a"
            result.assertTasksExecuted(":b", ":a")
        }
    }

    @UnsupportedWithConfigurationCache
    def buildFinishedHookCanAccessTaskGraph() {

		desc   string
		in     string
		expect string
		err    error
	}{
		{
			desc: "empty",
			in:   ``,
			expect: `spec: {}
`,
			err: nil,
		},
		{
			desc: "add-root",
			in: `
a: va
b: foo`,
			expect: `spec:
  a: va
  b: foo
`,
			err: nil,
		},
		{
			desc:   "err",
			in:     `i can't be yaml, can I?`,
			expect: ``,
			err:    errors.New(""),
		},
	}