equal: false,
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			// 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)
			}

			},
			want: false,
		},
	}

	for _, tc := range cases {
		t.Run(tc.desc, func(t *testing.T) {
			opts := WorkloadPolicyMatcher{
				Namespace:      "ns",
				WorkloadLabels: tc.proxyLabels,
				IsWaypoint:     false,
			}
			got := tc.wasmPlugin.MatchListener(opts, tc.listenerInfo)
			if tc.want != got {
				t.Errorf("MatchListener got %v want %v", got, tc.want)
			}
		})
	}

			expectErrors:         true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			err := validateMaxCIDRRange(tc.cidr, tc.maxCIDRBits, tc.cidrFlag)
			if err != nil && !tc.expectErrors {
				t.Errorf("expected no errors, error found %+v", err)
			}

			if err == nil && tc.expectErrors {
				t.Errorf("expected errors, no errors found")
			}

		return
	}

	tc.queue.AddAfter(key, after)
}

func (tc *Controller) worker(ctx context.Context) {
	for tc.processNextWorkItem(ctx) {
	}
}

func (tc *Controller) processNextWorkItem(ctx context.Context) bool {
	key, quit := tc.queue.Get()
	if quit {
		return false
	}
	defer tc.queue.Done(key)

	err := tc.processJob(ctx, key)
	tc.handleErr(err, key)

	return true
}

		t.Errorf("failed reading index %s (%s)", tc.name, err)
	}
	if !equal(x, &y) {
		t.Errorf("restored index doesn't match saved index %s", tc.name)
	}

	return size
}

func testIndex(t *testing.T) {
	for _, tc := range testCases {
		x := New([]byte(tc.source))
		testConstruction(t, &tc, x)
		testSaveRestore(t, &tc, x)
		testLookups(t, &tc, x, 0)
		testLookups(t, &tc, x, 1)
		testLookups(t, &tc, x, 10)

				pod := validNewPod()
				pod.Name = tc.podName
				pod.Labels = map[string]string{"a": "true"}
				pod.Spec.NodeName = "foo"
				if tc.podPhase != "" {
					pod.Status.Phase = tc.podPhase
				}

				if tc.podTerminating {
					currentTime := metav1.Now()
					pod.ObjectMeta.DeletionTimestamp = &currentTime
				}

				// Setup pod condition
				if tc.prc != nil {

		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			rnr, err := newInternal(tc.handler)
			assert.NoError(t, err)

			err = rnr.Add(tc.counterName)
			if tc.err != nil {
				assert.ErrorContains(t, err, tc.err.Error())
			} else {
				assert.NoError(t, err)
			}

			// validate number of requests
			assert.Equal(t, tc.netlinkCalls, len(tc.handler.requests))

				if err != nil {
					t.Errorf("both permission and principal returned error")
				}
			} else {
				_, err1 := tc.g.principal(tc.key, tc.value, tc.forTCP, false)
				_, err2 := tc.g.permission(tc.key, tc.value, tc.forTCP)
				if err1 == nil || err2 == nil {
					t.Fatalf("wanted error")
				}
				return
			}
			if diff := cmp.Diff(got, tc.want, protocmp.Transform()); diff != "" {

			tcp:      &tcp.TcpProxy{},
			class:    networking.ListenerClassSidecarInbound,
			expected: &tcp.TcpProxy{},
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			b.setTCPAccessLog(tc.push, tc.proxy, tc.tcp, tc.class, nil)
			assert.Equal(t, tc.expected, tc.tcp)
		})
	}
}

func TestSetHttpAccessLog(t *testing.T) {
	b := newAccessLogBuilder()

	env := newTestEnviroment()

		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			token := outputapiv1alpha3.BootstrapToken{
				BootstrapToken: bootstraptokenv1.BootstrapToken{
					Token:       &bootstraptokenv1.BootstrapTokenString{ID: tc.id, Secret: tc.secret},
					Description: tc.description,
					Usages:      tc.usages,
					Groups:      tc.extraGroups,
				},
			}
			buf := bytes.Buffer{}