- `spec.backend` -> `spec.defaultBackend`
  - `serviceName` -> `service.name`
  - `servicePort` -> `service.port.name` (for string values)

            final List<? extends Terms.Bucket> buckets = agg.getBuckets();
            updatePagerByAgg(pager, buckets.size());
            return buckets.stream().map(e -> {
                final Map<String, Object> map = new HashMap<>();
                map.put(ID, Base64.getUrlEncoder().encodeToString(e.getKeyAsString().getBytes(StandardCharsets.UTF_8)));
                map.put(KEY, e.getKeyAsString());

        // Note: Directly verifying super constructor calls is not straightforward in JUnit/Mockito.
        // We verify the effects of the super constructor by checking the fields of the created object.

        // Assert object_attributes fields
        assertNotNull(msrpcLsarOpenPolicy2.object_attributes);
        assertEquals(24, msrpcLsarOpenPolicy2.object_attributes.length);

    val uppercaseBody: ResponseBody =
      object : ForwardingResponseBody(response.body) {
        override fun source(): BufferedSource = uppercaseSource(delegate().source()).buffer()
      }
    return response
      .newBuilder()
      .body(uppercaseBody)
      .build()
  }

  private fun uppercaseSource(source: BufferedSource): ForwardingSource {
    return object : ForwardingSource(source) {

        "components": {
            "schemas": {
                "ValidationError": {
                    "title": "ValidationError",
                    "required": ["loc", "msg", "type"],
                    "type": "object",
                    "properties": {
                        "loc": {
                            "title": "Location",
                            "type": "array",
                            "items": {

                }
            }
        },
        "components": {
            "schemas": {
                "HTTPValidationError": {
                    "title": "HTTPValidationError",
                    "type": "object",
                    "properties": {
                        "detail": {
                            "title": "Detail",
                            "type": "array",

// Copyright (c) 2015-2021 MinIO, Inc.
//
// This file is part of MinIO Object Storage stack
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful

 */

package gradlebuild.binarycompatibility

import groovy.transform.Immutable

@Immutable
class ApiChange {
    String type
    String member
    List<String> changes

    static ApiChange parse(Object json) {
        new ApiChange(json.type, json.member, json.changes ?: [])
    }

    String toString() {
        def formattedMember = member - "$type."
        "$type - $formattedMember - $changes"
    }

              return singleton("a").iterator();
            }
          });
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
  }

  public void testIsEmpty_map() {
    Map<Object, Object> map = new HashMap<>();
    assertEmpty(map);

    map.put("a", "b");
    try {
      assertEmpty(map);
      throw new Error();
    } catch (AssertionFailedError expected) {
    }
  }

## Using `Jinja2Templates` { #using-jinja2templates }

* Import `Jinja2Templates`.
* Create a `templates` object that you can reuse later.
* Declare a `Request` parameter in the *path operation* that will return a template.
* Use the `templates` you created to render and return a `TemplateResponse`, pass the name of the template, the request object, and a "context" dictionary with key-value pairs to be used inside of the Jinja2 template.