if pdb.Spec.MaxUnavailable != nil {
		expectedCount, unmanagedPods, err = dc.getExpectedScale(ctx, pdb, pods)
		if err != nil {
			return
		}
		var maxUnavailable int
		maxUnavailable, err = intstr.GetScaledValueFromIntOrPercent(pdb.Spec.MaxUnavailable, int(expectedCount), true)
		if err != nil {
			return
		}
		desiredHealthy = expectedCount - int32(maxUnavailable)
		if desiredHealthy < 0 {

   *
   * @param numBytes the number of bytes in the byte array
   * @param expectedCount the expected number of roundtrippable permutations
   */
  @GwtIncompatible // java.nio.charset.Charset
  private static void testBytes(int numBytes, long expectedCount) {
    testBytes(numBytes, expectedCount, 0, -1);
  }

  /**

        if (initRight == null) {
          result[0] = 0;
          if (expectedCount == 0 && newCount > 0) {
            return addRightChild(e, newCount);
          }
          return this;
        }

        right = initRight.setCount(comparator, e, expectedCount, newCount, result);

        if (result[0] == expectedCount) {
          if (newCount == 0 && result[0] != 0) {
            this.distinctElements--;

	tcases := []struct {
		name          string
		bits          []int
		expectedCount int
	}{
		{
			name:          "Count number of bits set in mask 00",
			bits:          nil,
			expectedCount: 0,
		},
		{
			name:          "Count number of bits set in mask 01",
			bits:          []int{0},
			expectedCount: 1,
		},
		{
			name:          "Count number of bits set in mask 11",

        if (initRight == null) {
          result[0] = 0;
          if (expectedCount == 0 && newCount > 0) {
            return addRightChild(e, newCount);
          }
          return this;
        }

        right = initRight.setCount(comparator, e, expectedCount, newCount, result);

        if (result[0] == expectedCount) {
          if (newCount == 0 && result[0] != 0) {
            this.distinctElements--;

func (f *FakeRuntime) AssertCallCounts(funcName string, expectedCount int) bool {
	f.Lock()
	defer f.Unlock()
	actualCount := 0
	for _, c := range f.CalledFunctions {
		if funcName == c {
			actualCount += 1
		}
	}
	if expectedCount != actualCount {
		f.T.Errorf("AssertCallCounts: expected %s to be called %d times, but was actually called %d times.", funcName, expectedCount, actualCount)
		return false
	}
	return true

        if (project) {
            path = project + '/' + path
        }
        return sampleDir.file(path)
    }

    private static void assertTestsRunCount(resultsXml, int expectedCount) {
        assert resultsXml.@tests == expectedCount
    }

    private static void assertTestRun(resultsXml, String testName) {
        assert resultsXml.testcase.find { it.@name == testName }
    }

		},
	}

	for _, test := range tests {
		t.Run(test.Name, func(t *testing.T) {
			rs := GetReplicaCountForReplicaSets(test.sets)
			if rs != test.expectedCount {
				t.Errorf("In test case %s, expectedCount %+v, got %+v", test.Name, test.expectedCount, rs)
			}
			rs = GetActualReplicaCountForReplicaSets(test.sets)
			if rs != test.expectedActual {

        outs.each {String expectedOut ->
            def filters = outs.findAll { other -> other != expectedOut && other.startsWith(expectedOut) }

            // Find all locations of the expected string in the output
            List<Integer> matches = []
            int pos = 0;
            while (pos < result.length()) {
                int match = result.indexOf(expectedOut, pos)
                if (match < 0) {

		defaultGVK              *schema.GroupVersionKind
		intoObj                 runtime.Object

		errFunc                     func(error) bool
		expectedGVKOfSerializedData *schema.GroupVersionKind
		expectedOut                 runtime.Object
	}{
		{
			name:       "decode v1 unstructured into non-nil v2 unstructured",
			serializer: &mockSerializer{actual: &v1GVK, obj: v1UnstructuredDecodable},