<div class="container-fluid">
                <div class="row mb-2">
                    <div class="col-sm-6">
                        <h1>
                            <la:message key="labels.error_title"/>
                        </h1>
                    </div>
                </div>
            </div>
        </div>
        <section class="content">
            <div class="callout callout-danger lead">
                <p>

        OldBase returnTypeOverridenMethod() { return null }
    }

    static class OldSub extends OldBase {
        OldSub returnTypeOverridenMethod() { return null }
    }

    static class NewSuperInternal {}

    static class NewBase extends NewSuperInternal {}

    static class NewSub extends NewBase {}

    Map classes = [:]

    def setup() {

    void testExtendsDecodable() {
        Class<?>[] interfaces = SecurityInfo.class.getInterfaces();
        assertTrue(Arrays.asList(interfaces).contains(jcifs.Decodable.class), "SecurityInfo should extend Decodable interface");
    }

    @Test
    @DisplayName("Test all constant fields count")
    void testConstantFieldsCount() {
        Field[] fields = SecurityInfo.class.getDeclaredFields();

    Property<String> getSomeProperty()
}
class Example {
    @Nested
    NestedType getNestedProperty()
}
```
Otherwise, if the nested type requires an implementation class, you'll need to manage the lifecycle of it:
```
interface NestedType {
    Property<String> getSomeProperty()
    void notManaged()
}
abstract class DefaultNestedType implements NestedType {
    ...
}

class Example {
    private final NestedType nested

    Call call = client.newCall(request);

    assertEquals(5, call.tag(Integer.class));
    assertEquals("hello", call.tag(String.class));
    assertEquals(null, call.tag(Boolean.class));
    assertEquals(null, call.tag(Object.class));
  }

  @Test
  public void tagsCanBeComputed() {
    Request request = new Request.Builder()
      .url(HttpUrl.get("https://square.com/"))
      .build();
    Call call = client.newCall(request);

        java.lang.reflect.Field field = TestBean.class.getDeclaredField("directField");

        // First access
        helper.setProperty(bean1, "directField", String.class, config);
        boolean accessibilityAfterFirst = field.canAccess(bean1);

        // Second access with different bean
        config.setValue("value2");
        helper.setProperty(bean2, "directField", String.class, config);

        assertSame(session, session.unwrap(SmbSessionInternal.class));
        assertSame(session, session.unwrap(jcifs.SmbSession.class));

        // Edge: force incompatible class via raw type to trigger ClassCastException
        assertThrows(ClassCastException.class, () -> session.unwrap((Class) String.class));
    }

    @Test
    @DisplayName("toString contains key identifiers")

import org.codehaus.plexus.util.xml.Xpp3Dom;

/**
 * <strong>Warning:</strong> This is an internal class that is only public for technical reasons, it is not part of the
 * public API. In particular, this class can be changed or deleted without prior notice.
 *
 */
@Named
@Singleton
public class DefaultBeanConfigurator implements BeanConfigurator {

    private final ConverterLookup converterLookup;

    assertThat(cacheEvents()).containsExactly(CacheMiss::class)

    result = cachedDns.lookup("google.com")
    assertThat(server.takeRequest(1, TimeUnit.MILLISECONDS)).isNull()
    assertThat(result).isEqualTo(listOf(address("157.240.1.18")))

    assertThat(cacheEvents()).containsExactly(CacheHit::class)

    result = cachedDns.lookup("www.google.com")

    <inspection_tool class="CatchMayIgnoreException" enabled="true" level="ERROR" enabled_by_default="true" />
    <inspection_tool class="Convert2streamapi" enabled="false" level="INFORMATION" enabled_by_default="false" />
    <inspection_tool class="EqualsBetweenInconvertibleTypes" enabled="true" level="ERROR" enabled_by_default="true" />
    <inspection_tool class="FieldNamingConvention" enabled="true" level="ERROR" enabled_by_default="true">