Model model;
        try (InputStream is = getClass().getResourceAsStream("/xml/pom.xml")) {
            model = new MavenXpp3Reader().read(is);
        }

        // Serialize an inner child here so that the BaseObject.childrenTracking is non null
        Build build = model.getBuild();

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

 This is strictly the immutable model for Maven settings in <<<org.apache.maven.api.settings>>> package.

 The following are generated from this model:

   * {{{./apidocs/index.html}Java sources}} with <<<Builder>>> inner classes for immutable instances creation.

 See also corresponding {{{../../compat/maven-settings/index.html}Maven classical settings model documentation}}.

            HMACT64 hmac = new HMACT64(TEST_KEY);
            byte[] result = hmac.engineDigest();

            assertArrayEquals(finalDigest, result);
            verify(mockMd5, times(1)).digest(); // First call for inner digest
            verify(mockMd5, times(2)).update(any(byte[].class)); // Once in constructor with ipad, once in engineDigest with opad
            verify(mockMd5, times(1)).digest(innerDigest); // Second call for final digest

 The following are generated from this model:

   * {{{./apidocs/index.html}Java sources}} with <<<Builder>>> inner classes for immutable instances creation.

                  protected Set<String> create(String[] elements) {
                    Multiset<String> inner = LinkedHashMultiset.create(asList(elements));
                    return new ForwardingMultiset<String>() {
                      @Override
                      protected Multiset<String> delegate() {
                        return inner;
                      }

                      @Override

        assertEquals(228L, MemoryUtil.sizeOf(mixedMap));

        // Nested maps
        Map<String, Map<String, String>> nestedMap = new HashMap<>();
        nestedMap.put("outer", Maps.map("inner", "value").$());
        assertEquals(183L, MemoryUtil.sizeOf(nestedMap));
    }

    @Test
    public void test_sizeOf_customObjects() {
        // Test fallback case for custom objects (should return 16L)

    assertFalse(delegate.isOverridable());
    assertFalse(delegate.isVarArgs());
  }

  @SuppressWarnings("ClassCanBeStatic") // We want to test an inner class.
  private class InnerWithDefaultConstructor {
    class NestedInner {}
  }

  public void testInnerClassDefaultConstructor() {

  fun noRequestBody() {
    call.messageDone(
      exchange = this,
      requestDone = true,
      e = null,
    )
  }

  /** A request body that fires events when it completes. */
  private inner class RequestBodySink(
    delegate: Sink,
    /** The exact number of bytes to be written, or -1L if that is unknown. */
    private val contentLength: Long,
    private val isSocket: Boolean,

        // Test inner class LangAnalyzerConverter init
        AnalyzerConverter.LangAnalyzerConverter langConverter = converter.new LangAnalyzerConverter("en");

        langConverter.init();
        // Should not throw exception
    }

    @Test
    public void testLangAnalyzerConverterWithNullLang() throws IOException {
        // Test inner class with null language

  ): Sink = FaultySink(super.appendingSink(file, mustExist), file)

  override fun sink(
    file: Path,
    mustCreate: Boolean,
  ): Sink = FaultySink(super.sink(file, mustCreate), file)

  inner class FaultySink(
    sink: Sink,
    private val file: Path,
  ) : ForwardingSink(sink) {
    override fun write(
      source: Buffer,
      byteCount: Long,
    ) {