/** @since 2.0 */
        @Incubating
        fun wrap(a: kotlin.collections.HashMap<String, String>, b: kotlin.collections.LinkedHashMap<String, String>): Unit = Unit

    """

    @Test
    fun `new top-level kotlin members`() {

        checkNotBinaryCompatibleKotlin(
            v2 = """

           $publicKotlinMembers

            const val cathedral = "cathedral"

            """

    final Chopper or(Chopper you) {
      Chopper i = this;
      return new Chopper() {
        @Override
        Optional<String> chop(String str) {
          return i.chop(str).or(you.chop(str));
        }
      };
    }

    abstract Optional<String> chop(String str);

    static Chopper suffix(String suffix) {
      return new Chopper() {
        @Override
        Optional<String> chop(String str) {

 */
@DisplayName("PluginUpgradeStrategy")
class PluginUpgradeStrategyTest {

    private PluginUpgradeStrategy strategy;

    @BeforeEach
    void setUp() {
        strategy = new PluginUpgradeStrategy();
    }

    private UpgradeContext createMockContext() {
        return TestUtils.createMockContext();
    }

    private UpgradeContext createMockContext(UpgradeOptions options) {

	v, ok := h["Content-Md5"]
	if !ok {
		return nil, nil
	}
	if v[0] == "" {
		return nil, errors.New("etag: content-md5 is set but contains no value")
	}
	b, err := base64.StdEncoding.Strict().DecodeString(v[0])
	if err != nil {
		return nil, err
	}
	if len(b) != md5.Size {
		return nil, errors.New("etag: invalid content-md5")
	}
	return ETag(b), nil
}

            if (family == 2) { // AF_INET
                byte[] addr = new byte[4];
                System.arraycopy(data, offset + 4, addr, 0, 4);
                return InetAddress.getByAddress(addr);
            } else if (family == 23) { // AF_INET6
                byte[] addr = new byte[16];
                System.arraycopy(data, offset + 8, addr, 0, 16);

    }

    @Test
    void helpMentionsInferInDefault() throws Exception {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ByteArrayOutputStream err = new ByteArrayOutputStream();

        int exit = MavenUpCling.main(
                new String[] {"--help"},
                new ClassWorld("plexus.core", Thread.currentThread().getContextClassLoader()),
                null,
                out,

* The alternative documentation will also reflect the new query parameter and body:

![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)

### Recap { #recap }

In summary, you declare **once** the types of parameters, body, etc. as function parameters.

You do that with standard modern Python types.

You don't have to learn a new syntax, the methods or classes of a specific library, etc.

    static {
        final Map<Integer, String> errorCodeMessagesTmp = new HashMap<>();
        for (int i = 0; i < NT_STATUS_CODES.length; i++) {
            errorCodeMessagesTmp.put(NT_STATUS_CODES[i], NT_STATUS_MESSAGES[i]);
        }

        final Map<Integer, Integer> dosErrorCodeStatusesTmp = new HashMap<>();
        for (final int[] element : DOS_ERROR_CODES) {

    // we delegate to the current classloader so both loaders agree on classes like TestCase
    return new URLClassLoader(ClassPathUtil.getClassPathUrls(), classLoader) {
      @Override
      public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (disallowedClassNames.contains(name)) {
          throw new ClassNotFoundException("I'm sorry Dave, I'm afraid I can't do that.");
        }

  private void testThreshold(
      int fileThreshold, int dataSize, boolean singleByte, boolean resetOnFinalize)
      throws IOException {
    byte[] data = newPreFilledByteArray(dataSize);
    FileBackedOutputStream out = new FileBackedOutputStream(fileThreshold, resetOnFinalize);
    ByteSource source = out.asByteSource();
    int chunk1 = min(dataSize, fileThreshold);
    int chunk2 = dataSize - chunk1;