`DELETE / "c308"`,
		`DELETE /?code=404 "c404"`,
	}
	want := strings.Join(wantSegments, "\n")
	run(t, func(t *testing.T, mode testMode) {
		testRedirectsByMethod(t, mode, "DELETE", deleteRedirectTests, want)
	})
}

func testRedirectsByMethod(t *testing.T, mode testMode, method string, table []redirectTest, want string) {
	var log struct {
		sync.Mutex
		bytes.Buffer
	}
	var ts *httptest.Server

// in "Range": "bytes=-N", and should reject "bytes=--2".
func TestServeFileRejectsInvalidSuffixLengths(t *testing.T) {
	run(t, testServeFileRejectsInvalidSuffixLengths, []testMode{http1Mode, https1Mode, http2Mode})
}
func testServeFileRejectsInvalidSuffixLengths(t *testing.T, mode testMode) {
	cst := newClientServerTest(t, mode, FileServer(Dir("testdata"))).ts

	tests := []struct {
		r        string
		wantCode int
		wantBody string

		// Validate
		if !scenario.shouldFail && err != nil {
			t.Errorf("returned error: %v", err)
		}
		if scenario.shouldFail && err == nil {
			t.Error("returned success but expected error")
		}
		checkReasons(t, reasons, scenario.reasons)
		testEnv.validatePodCache(t, testNode.Name, scenario.pod, podVolumes, scenario.expectedBindings, nil)
	}

        for (ClassNode testNode : outerClasses) {
            val = new ConstructedNestedClass(testNode, type.getName());
            if (resolveFromCompileUnit(val)) {
                type.setRedirect(val);
                return true;
            }
            // also check interfaces in case we have interfaces with nested classes
            for (ClassNode next : testNode.getAllInterfaces()) {

		},
	}

	testNode := &model.Proxy{
		Labels: map[string]string{
			"app": "foo",
		},
		Metadata: &model.NodeMetadata{},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			got := newPolicyApplier("root-namespace", nil, tc.peerPolicies, &model.PushContext{}).InboundMTLSSettings(
				8080,
				testNode,
				[]string{},
				NoOverride,
			)

        return result
    }

    private static class TestNode extends CreationOrderedNode implements SelfExecutingNode {
        final Throwable failure
        final String name
        final List<Node> preExecuteNodes
        final List<Node> postExecuteNodes

	return Quantity{d: bigDec(i, exponent), Format: format}
}

func intQuantity(i int64, exponent Scale, format Format) Quantity {
	return Quantity{i: int64Amount{value: i, scale: exponent}, Format: format}
}

func TestDec(t *testing.T) {
	table := []struct {
		got    infDecAmount
		expect string
	}{
		{dec(1, 0), "1"},
		{dec(1, 1), "10"},
		{dec(5, 2), "500"},
		{dec(8, 3), "8000"},
		{dec(2, 0), "2"},

		// If the OS supports symlinks, use them instead of copying bytes.
		testExe, err := os.Executable()
		if err != nil {
			log.Fatal(err)
		}
		if err := os.Symlink(testExe, testGo); err != nil {
			// Otherwise, copy the bytes.
			src, err := os.Open(testExe)
			if err != nil {
				log.Fatal(err)
			}
			defer src.Close()