}

	for i := range testCases {
		tc := &testCases[i]
		pr := &PortRange{}
		var f flag.Value = pr
		err := f.Set(tc.input)
		if err != nil && tc.success {
			t.Errorf("expected success, got %q", err)
			continue
		} else if err == nil && !tc.success {
			t.Errorf("expected failure %#v", testCases[i])
			continue
		} else if tc.success {
			if f.String() != tc.expected {

		}

		var hasError bool
		for _, r := range tc.fake.results {
			hasError = hasError || (r != nil)
		}
		if hasError != tc.wantError {
			t.Errorf("%v, %v; hasError = %t, errors = %v, want %t",
				tc.desc, tc.mode, hasError, tc.fake.events, tc.wantError)
		}
	}
}

func TestNodeSyncResync(t *testing.T) {
	logger, _ := ktesting.NewTestContext(t)
	fake := &fakeAPIs{

		},
	}

	for _, tc := range tcs {
		actual, err := mutationAnnotationValue(tc.config, tc.webhook, tc.mutated)
		assert.NoError(t, err, "unexpected error")
		if actual != tc.expected {
			t.Errorf("composed mutation annotation value doesn't match, want: %s, got: %s", tc.expected, actual)
		}
	}
}

func TestJSONPatchAnnotationValue(t *testing.T) {

		{multiErr{poser}, err1, true},
		{multiErr{poser}, err3, true},
		{multiErr{nil}, nil, false},
	}
	for _, tc := range testCases {
		t.Run("", func(t *testing.T) {
			if got := errors.Is(tc.err, tc.target); got != tc.match {
				t.Errorf("Is(%v, %v) = %v, want %v", tc.err, tc.target, got, tc.match)
			}
		})
	}
}

type poser struct {
	msg string
	f   func(error) bool
}

				t.Errorf("For %s: expected staging path %s got %s", tc.name, tc.deviceStagePath, stagingTargetPath)
			}

			if ok != tc.success {
				if err != nil {
					t.Errorf("For %s : expected %v got %v with %v", tc.name, tc.success, ok, err)
				} else {
					t.Errorf("For %s : expected %v got %v", tc.name, tc.success, ok)
				}
			}

		},
	}

	for _, tc := range tests {
		t.Run(tc.in, func(t *testing.T) {
			pkg, sym := splitPkg(tc.in)
			if pkg != tc.pkg {
				t.Errorf("splitPkg(%q) got pkg %q want %q", tc.in, pkg, tc.pkg)
			}
			if sym != tc.sym {
				t.Errorf("splitPkg(%q) got sym %q want %q", tc.in, sym, tc.sym)
			}
		})
	}

	scope.podTopologyHints = podTopologyHints{}
	for _, tc := range testCases {
		scope.podMap.Add(string(tc.podUID), tc.name, tc.containerID)
		scope.podTopologyHints[string(tc.podUID)] = make(map[string]TopologyHint)
		scope.podTopologyHints[string(tc.podUID)][tc.name] = TopologyHint{}
		len1 = len(scope.podMap)
		lenHints1 = len(scope.podTopologyHints)
		err := scope.RemoveContainer(tc.containerID)
		len2 = len(scope.podMap)

			expectError: true,
			contents:    &TracingOptions{ConfigFile: "/path/doesnt/exist"},
		},
	}

	for _, tc := range testcases {
		t.Run(tc.name, func(t *testing.T) {
			errs := tc.contents.Validate()
			if !tc.expectError && len(errs) != 0 {
				t.Errorf("Calling Validate expected no error, got %v", errs)
			} else if tc.expectError && len(errs) == 0 {
				t.Errorf("Calling Validate expected error, got no error")
			}
		})
	}
}

			IstioVersion(""),
			0,
		},
		{
			IstioVersion(""),
			IstioVersion("1.9"),
			1,
		},
	}

	for _, tc := range tcs {
		t.Run(fmt.Sprintf("compare version %s->%s", tc.a, tc.b), func(t *testing.T) {
			r := tc.a.Compare(tc.b)
			if r != tc.result {
				t.Errorf("expected %d, got %d", tc.result, r)
			}
		})
	}
}

func TestMinimumIstioVersion(t *testing.T) {
	tcs := []struct {
		name     string

		{"abc", "acca", -1},
		{"aa", "aaa", 0},
		{"baa", "aaaaa", -1},
		{"at that", "which finally halts.  at that point", 22},
	}

	for _, tc := range testCases {
		got := StringFind(tc.pat, tc.text)
		want := tc.index
		if got != want {
			t.Errorf("stringFind(%q, %q) got %d, want %d\n", tc.pat, tc.text, got, want)
		}
	}
}

func TestFinderCreation(t *testing.T) {
	testCases := []struct {
		pattern string
		bad     [256]int