//   factory:          pointer to the factory that creates a test object.
//                     The newly created TestInfo instance will assume
//                     ownership of the factory object.
GTEST_API_ TestInfo* MakeAndRegisterTestInfo(
    const char* test_case_name,
    const char* name,
    const char* type_param,
    const char* value_param,
    TypeId fixture_class_id,

                runtimeMinus.add(providedRuntime);
                Collection<Configuration> testMinus = ideaModule.getModule().getScopes().get(GeneratedIdeaScope.TEST.name()).get(IdeaDependenciesProvider.SCOPE_MINUS);
                testMinus.add(providedRuntime);
            }
        });
    }

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/client-go/dynamic"
	_ "k8s.io/component-base/logs/testinit" // enable logging flags
)

var swaggerMetadataDescriptions = metav1.ObjectMeta{}.SwaggerDoc()

		panic(fmt.Sprintf("_Max(%v) = %q, want %q", s2, got, want))
	}

	if got, want := _SliceMax(s2[:0]), ""; got != want {
		panic(fmt.Sprintf("_Max(%v) = %q, want %q", s2[:0], got, want))
	}
}

func TestMin() {
	s1 := []int{1, 2, 3, -5}
	if got, want := _SliceMin(s1), -5; got != want {
		panic(fmt.Sprintf("_Min(%v) = %d, want %d", s1, got, want))
	}

	s2 := []string{"aaa", "a", "aa", "aaaa"}

        UnsignedInteger unsignedSum = aUnsigned.plus(bUnsigned);
        assertThat(unsignedSum.intValue()).isEqualTo(expected);
      }
    }
  }

  public void testMinus() {
    for (int a : TEST_INTS) {
      for (int b : TEST_INTS) {
        UnsignedInteger aUnsigned = UnsignedInteger.fromIntBits(a);
        UnsignedInteger bUnsigned = UnsignedInteger.fromIntBits(b);

  }

  public void testMin_noArgs() {
    try {
      SignedBytes.min();
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMin() {
    assertThat(SignedBytes.min(LEAST)).isEqualTo(LEAST);
    assertThat(SignedBytes.min(GREATEST)).isEqualTo(GREATEST);
    assertThat(SignedBytes.min((byte) 0, (byte) -128, (byte) -1, (byte) 127, (byte) 1))

        UnsignedLong unsignedSum = aUnsigned.plus(bUnsigned);
        assertThat(unsignedSum.longValue()).isEqualTo(expected);
      }
    }
  }

  public void testMinus() {
    for (long a : TEST_LONGS) {
      for (long b : TEST_LONGS) {
        UnsignedLong aUnsigned = UnsignedLong.fromLongBits(a);
        UnsignedLong bUnsigned = UnsignedLong.fromLongBits(b);
        long expected =

		if err != nil && pmain.Error == nil {
			pmain.Error = &PackageError{Err: err}
			pmain.Incomplete = true
		}
		// Set TestmainGo even if it is empty: the presence of a TestmainGo
		// indicates that this package is, in fact, a test main.
		pmain.Internal.TestmainGo = &data
	}

	if done != nil {
		go func() {
			parallelizablePart()
			done()
		}()
	} else {
		parallelizablePart()
	}

        UnsignedInteger unsignedSum = aUnsigned.plus(bUnsigned);
        assertThat(unsignedSum.intValue()).isEqualTo(expected);
      }
    }
  }

  public void testMinus() {
    for (int a : TEST_INTS) {
      for (int b : TEST_INTS) {
        UnsignedInteger aUnsigned = UnsignedInteger.fromIntBits(a);
        UnsignedInteger bUnsigned = UnsignedInteger.fromIntBits(b);

  }

  public void testMin_noArgs() {
    try {
      SignedBytes.min();
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMin() {
    assertThat(SignedBytes.min(LEAST)).isEqualTo(LEAST);
    assertThat(SignedBytes.min(GREATEST)).isEqualTo(GREATEST);
    assertThat(SignedBytes.min((byte) 0, (byte) -128, (byte) -1, (byte) 127, (byte) 1))