if err != nil {
				t.Fatalf("ParseUnixRights: %v", err)
			}
			wantFds := testCase[i]
			if len(gotFds) != len(wantFds) {
				t.Fatalf("expected %v fds, got %#v", len(wantFds), gotFds)
			}
			for j, fd := range gotFds {
				if fd != wantFds[j] {
					t.Fatalf("expected fd %v, got %v", wantFds[j], fd)
				}
			}
		}
	}
}

func TestSeekFailure(t *testing.T) {

		}
		np := mfr.NumPackages()
		if np != 7 {
			t.Fatalf("k=%d wanted 7 packages got %d", k, np)
		}
		md := mfr.CounterMode()
		wmd := coverage.CtrModeAtomic
		if md != wmd {
			t.Fatalf("k=%d wanted mode %d got %d", k, wmd, md)
		}
		gran := mfr.CounterGranularity()
		wgran := coverage.CtrGranularityPerBlock
		if gran != wgran {
			t.Fatalf("k=%d wanted gran %d got %d", k, wgran, gran)
		}

		payload := []byte{}

						},
					},
				},
			},
			wantErr: nil,
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if _, wanted2 := NewAnalyzer(tt.input); wanted2 != nil {
				t.Errorf("Wanted %v, got %v", tt.wantErr, wanted2)
			}
		})
	}
}

func TestPrint(t *testing.T) {
	a := &Analyzer{
		listenerDump: &envoy_admin.ListenersConfigDump{

		backend := b.(*fakeBackend)

		if got := len(backend.events); got != n {
			t.Errorf("backend %d wanted %d events, got %d", i, n, got)
			continue
		}
		for j, event := range backend.events {
			wantID := types.UID(strconv.Itoa(j))
			if event.AuditID != wantID {
				t.Errorf("backend %d event %d wanted id %s, got %s", i, j, wantID, event.AuditID)
			}
		}
	}
}

type cannotMultipleRunBackend struct {

			for _, ip := range ips {
				gotIPs[ip.String()] = struct{}{}
			}
			wantIPs := map[string]struct{}{}
			if wantErr == nil {
				for _, ip := range tt.wantIPs {
					wantIPs[ip] = struct{}{}
				}
			}
			if !reflect.DeepEqual(gotIPs, wantIPs) {
				t.Errorf("#%d (%s) strict=%v: got ips %v; want %v", i, tt.desc, strict, gotIPs, wantIPs)
			}
		}
	}
}

	wantu := uint64(0x4000000000000000)
	if got := arithRshuConst_ssa(); got != wantu {
		t.Errorf("arithRshuConst failed, wanted %d got %d", wantu, got)
	}

	wants := int64(-0x4000000000000000)
	if got := arithRshConst_ssa(); got != wants {
		t.Errorf("arithRshConst failed, wanted %d got %d", wants, got)
	}
}

//go:noinline
func arithRshuConst_ssa() uint64 {
	y := uint64(0x8000000000000001)
	z := uint64(1)

		uids := expectations.getSet(track.job)
		if uids != nil {
			t.Errorf("Wanted expectations for job %s to be cleared, but they were not", track.job)
		}
	}
}

func TestRecordFinishedPodWithTrackingFinalizer(t *testing.T) {
	metrics.Register()
	cases := map[string]struct {
		oldPod     *v1.Pod
		newPod     *v1.Pod
		wantAdd    int
		wantDelete int
	}{
		"new non-finished Pod with finalizer": {

}

func testCmp(t *testing.T) {
	if wanted, got := true, eq_ssa(6); wanted != got {
		t.Errorf("eq_ssa: expected %v, got %v\n", wanted, got)
	}
	if wanted, got := false, eq_ssa(7); wanted != got {
		t.Errorf("eq_ssa: expected %v, got %v\n", wanted, got)
	}
	if wanted, got := false, neq_ssa(6); wanted != got {
		t.Errorf("neq_ssa: expected %v, got %v\n", wanted, got)
	}
	if wanted, got := true, neq_ssa(7); wanted != got {

	panic("unreached")
}

func testAnd(t *testing.T, arg1, arg2, wantRes bool) {
	testShortCircuit(t, "AND", arg1, arg2, and_ssa, arg1, wantRes)
}
func testOr(t *testing.T, arg1, arg2, wantRes bool) {
	testShortCircuit(t, "OR", arg1, arg2, or_ssa, !arg1, wantRes)
}

func testShortCircuit(t *testing.T, opName string, arg1, arg2 bool, fn func(bool, bool) bool, wantRightCall, wantRes bool) {
	rightCalled = false
	got := fn(arg1, arg2)

		if contained != types.True {
			t.Errorf("got %v, wanted list contains elem[%v] %v == true", contained, i, e)
		}
	}
	if lv.Contains(types.String("fourth")) != types.False {
		t.Errorf("got %v, wanted false 'fourth'", lv.Contains(types.String("fourth")))
	}
	if !types.IsError(lv.Contains(types.Int(-1))) {
		t.Errorf("got %v, wanted error for invalid type", lv.Contains(types.Int(-1)))
	}
}