Matthew Dempsky <******@****.***> 1646087539 -0800

		t.Run(tc.name, func(t *testing.T) {
			equal := tc.a.Equal(tc.b)
			if equal != tc.equal {
				t.Errorf("Unexpected Equal result: got %t, want %t", equal, tc.equal)
			}
		})
	}

	public := &private.PublicKey

	if !public.Equal(public) {
		t.Errorf("public key is not equal to itself: %v", public)
	}
	if !public.Equal(crypto.Signer(private).Public().(*rsa.PublicKey)) {
		t.Errorf("private.Public() is not Equal to public: %q", public)
	}
	if !private.Equal(private) {
		t.Errorf("private key is not equal to itself: %v", private)
	}

	enc, err := x509.MarshalPKCS8PrivateKey(private)

	"istio.io/istio/pkg/test/util/assert"
)

func TestURL(t *testing.T) {
	assert.Equal(t, BaseURL, "https://istio.io/", "base url should be equal")
	assert.Equal(t, DocsURL, "https://istio.io/"+DocsVersion+"/docs/", "docs url should be equal")

	assert.Equal(t, OpsURL, "https://istio.io/"+DocsVersion+"/docs/ops/", "ops url should be equal")
	assert.Equal(t, DeploymentRequirements,
		"https://istio.io/"+DocsVersion+"/docs/ops/deployment/requirements/",

		{Equal, 12, vconst(20)},
		{Equal, 12, vconst2(20)},
		{Equal, 12, 25},

		{Equal, 15, 16},
		{Equal, 15, 17},
		{Equal, 15, 18},
		{Equal, 15, 19},
		{Equal, 15, vconst(20)},
		{Equal, 15, vconst2(20)},
		{Equal, 15, 25},

		{Equal, 16, 17},
		{Equal, 16, 18},
		{Equal, 16, 19},
		{Equal, 16, vconst(20)},
		{Equal, 16, vconst2(20)},
		{Equal, 16, 25},

		{Equal, 17, 18},

	assert.Equal(t, 1, fallThroughCount)
	assert.Equal(t, resp.StatusCode, http.StatusOK)
	resp, _ = http.Get(s.URL + "/publicPrefix")
	assert.Equal(t, 2, fallThroughCount)
	assert.Equal(t, resp.StatusCode, http.StatusOK)

	http.Get(s.URL + "/publicPrefix/")
	assert.Equal(t, 1, publicPrefixCount)
	http.Get(s.URL + "/publicPrefix/something")
	assert.Equal(t, 2, publicPrefixCount)

			// Compare types with schema against themselves
			if tc.lhs.Equal(tc.rhs) != types.Bool(tc.equal) {
				t.Errorf("expected Equals to return %v", tc.equal)
			}
			if tc.rhs.Equal(tc.lhs) != types.Bool(tc.equal) {
				t.Errorf("expected Equals to return %v", tc.equal)
			}

			// Compare types with schema against native types. This is slightly different than how

	}
}

func TestEqual() {
	if !a.Equal(m1, m1) {
		panic(fmt.Sprintf("a.Equal(%v, %v) = false, want true", m1, m1))
	}
	if a.Equal(m1, nil) {
		panic(fmt.Sprintf("a.Equal(%v, nil) = true, want false", m1))
	}
	if a.Equal(nil, m1) {
		panic(fmt.Sprintf("a.Equal(nil, %v) = true, want false", m1))
	}
	if !a.Equal[int, int](nil, nil) {
		panic("a.Equal(nil, nil) = false, want true")
	}

	req.Header.Set("Accept", accept)

	acceptWithReq := &lazyAccept{req}
	assert.Equal(t, accept, fmt.Sprintf("%v", acceptWithReq))

	acceptWithoutReq := &lazyAccept{}
	assert.Equal(t, "unknown", fmt.Sprintf("%v", acceptWithoutReq))
}

func TestLazyVerb(t *testing.T) {
	assert.Equal(t, "unknown", fmt.Sprintf("%v", &lazyVerb{}))

	u, _ := url.Parse("?watch=true")
	req := &http.Request{Method: "GET", URL: u}

	assert.Equal(t, set.List(), []string{"a", "b", "d"})
	assert.Equal(t, nset.List(), []string{"a", "b", "c", "d", "z"})

	assert.Equal(t, nset.Contains("a"), true)
	assert.Equal(t, nset.Contains("b"), true)
	assert.Equal(t, nset.Contains("c"), true)
	assert.Equal(t, nset.Contains("d"), true)
	assert.Equal(t, nset.Contains("e"), false)
	assert.Equal(t, nset.Contains("z"), true)
}

func TestNew(t *testing.T) {