return member instanceof JApiClass && !member.superclass.binaryCompatible && !member.superclass.compatibilityChanges.empty
    }

    @Override
    protected Violation checkSuperClassChanges(JApiClass apiClass, CtClass oldClass, CtClass newClass) {
        return acceptOrReject(apiClass.superclass, Violation.notBinaryCompatible(apiClass.superclass))
    }

          </code>
        </codeSegment>
      </codeSegments>
    </class>
    <class rootElement="true" xml.tagName="toolchains" xsd.compositor="sequence">
      <name>PersistedToolchains</name>
      <superClass>TrackableBase</superClass>
      <description>
        The {@code &lt;toolchains&gt;} element is the root of the descriptor.
        The following table lists all the possible child elements.
      </description>

import java.util.ArrayList;
import java.util.List;

public class AnnotatedNotAbstractInSuperclassTest extends AbstractEventBusTest<SubClass> {
  static class SuperClass {
    final List<Object> notOverriddenInSubclassEvents = new ArrayList<>();
    final List<Object> overriddenNotAnnotatedInSubclassEvents = new ArrayList<>();

public class AbstractNotAnnotatedInSuperclassTest extends AbstractEventBusTest<SubClass> {
  abstract static class SuperClass {
    public abstract void overriddenInSubclassNowhereAnnotated(Object o);

    public abstract void overriddenAndAnnotatedInSubclass(Object o);
  }

  static class SubClass extends SuperClass {
    final List<Object> overriddenInSubclassNowhereAnnotatedEvents = new ArrayList<>();

public class AnnotatedAndAbstractInSuperclassTest extends AbstractEventBusTest<SubClass> {
  abstract static class SuperClass {
    @Subscribe
    public abstract void overriddenAndAnnotatedInSubclass(Object o);

    @Subscribe
    public abstract void overriddenInSubclass(Object o);
  }

  static class SubClass extends SuperClass {
    final List<Object> overriddenAndAnnotatedInSubclassEvents = new ArrayList<>();

import java.util.ArrayList;
import java.util.List;

public class NeitherAbstractNorAnnotatedInSuperclassTest extends AbstractEventBusTest<SubClass> {
  static class SuperClass {
    final List<Object> neitherOverriddenNorAnnotatedEvents = new ArrayList<>();
    final List<Object> overriddenInSubclassNowhereAnnotatedEvents = new ArrayList<>();

  public static void testSubtypeOfStaticAnonymousClass() {
    Class<?> superclass = new Mall<Outdoor>().new Shop<Electronics>() {}.getClass();
    assertTrue(TypeToken.of(superclass).isSubtypeOf(superclass));
    assertFalse(
        TypeToken.of(new Mall<Outdoor>().new Shop<Electronics>() {}.getClass())
            .isSubtypeOf(superclass));
  }

    return (UnmodifiableListIterator<E>) delegateList.listIterator(index);
  }

  @GwtIncompatible // not present in emulated superclass
  @Override
  public void forEach(Consumer<? super E> action) {
    delegateList.forEach(action);
  }

  @GwtIncompatible // not present in emulated superclass
  @Override
  int copyIntoArray(@Nullable Object[] dst, int offset) {
    return delegateList.copyIntoArray(dst, offset);
  }

    }

    @Test
    @DisplayName("toString contains class name and delegates to superclass")
    void toStringMatches() {
        String s = response.toString();
        assertNotNull(s);
        assertTrue(s.startsWith("SmbComSetInformationResponse["));
        assertTrue(s.endsWith("]"));
        // Verify it contains superclass toString content
        assertTrue(s.length() > "SmbComSetInformationResponse[]".length());

        NameQueryRequest request = spy(new NameQueryRequest(mockConfig, mockName));
        byte[] dst = new byte[100];
        int dstIndex = 0;

        // Mock the superclass method to control its behavior
        doReturn(10).when((NameServicePacket) request).writeQuestionSectionWireFormat(any(byte[].class), anyInt());

        int result = request.writeBodyWireFormat(dst, dstIndex);