private final AtomicReference<Throwable> threadFailure = new AtomicReference<>(null);

  /**
   * Records an exception so that it can be rethrown later in the test harness thread, triggering a
   * test case failure. Only the first failure is recorded; subsequent calls to this method from
   * within the same test have no effect.
   */
  public void threadRecordFailure(Throwable t) {

    }

    def "#member change should not be reported"() {
        expect:
        noViolation(rule)

        where:
        member << [Mock(JApiMethod), Mock(JApiField), Mock(JApiImplementedInterface), Mock(JApiConstructor)]
    }

    def "nothing should be reported if no changes"() {
        expect:
        noViolation(rule)
    }

    def "nothing should be reported if new interface is neither internal nor incubating"() {

(Older toolchains ignore `//go:debug` directives entirely.)

The defaults that will be compiled into a main package
are reported by the command:

{{raw `
	go list -f '{{.DefaultGODEBUG}}' my/main/package
`}}

Only differences from the base Go toolchain defaults are reported.

When testing a package, `//go:debug` lines in the `*_test.go`
files are treated as directives for the test's main package.

        JApiCompatibilityChangeType.METHOD_REMOVED_IN_SUPERCLASS, // the removal of the method will be reported
        JApiCompatibilityChangeType.INTERFACE_REMOVED,            // the removed methods will be reported
        JApiCompatibilityChangeType.INTERFACE_ADDED               // the added methods will be reported
    );

    private static final Set<JApiCompatibilityChangeType> ANNOTATION_RELATED_CHANGES = Set.of(

        }

        Optional<CtClass> oldClass = member.oldClass
        Optional<CtClass> newClass = member.newClass
        if (!oldClass.isPresent() || !newClass.isPresent()) {
            // breaking change would be reported
            return null
        }

        return checkSuperClassChanges(member, oldClass.get(), newClass.get())
    }

    protected abstract boolean changed(JApiCompatibility member)

        classes['NewSub'].superclass = classes['NewBase']

        apiClass.compatibilityChanges >> [new JApiCompatibilityChange(JApiCompatibilityChangeType.METHOD_REMOVED_IN_SUPERCLASS)]
    }

    def "method removal can be reported if current class is first public class"() {
        given:
        apiClass.oldClass >> Optional.of(classes['OldBase'])
        apiClass.newClass >> Optional.of(classes['NewBase'])

        when:

            current = classesContainingMethod.get(i)
            if (!isInternal(current)) {
                // there's another public super class which contains target method
                // it would be reported somewhere else
                return false
            }
        }

        // I'm the top public class which contains target method
        return true
    }

    assertThat(segment.writeQueue).hasSize(1);

    segment.recordRead(entry, ticker.read());
    segment.expireEntries(ticker.read());
    assertThat(map.get(key)).isSameInstanceAs(value);
    assertThat(segment.writeQueue.peek()).isSameInstanceAs(entry);
    assertThat(segment.writeQueue).hasSize(1);

    ticker.advance(1);
    segment.recordRead(entry, ticker.read());
    segment.expireEntries(ticker.read());

    assertThat(segment.writeQueue).hasSize(1);

    segment.recordRead(entry, ticker.read());
    segment.expireEntries(ticker.read());
    assertThat(map.get(key)).isSameInstanceAs(value);
    assertThat(segment.writeQueue.peek()).isSameInstanceAs(entry);
    assertThat(segment.writeQueue).hasSize(1);

    ticker.advance(1);
    segment.recordRead(entry, ticker.read());
    segment.expireEntries(ticker.read());

    ],
)
def get_client(request: pytest.FixtureRequest):
    clear_sqlmodel()
    # TODO: remove when updating SQL tutorial to use new lifespan API
    with warnings.catch_warnings(record=True):
        warnings.simplefilter("always")
        mod = importlib.import_module(f"docs_src.sql_databases.{request.param}")
        clear_sqlmodel()
        importlib.reload(mod)
    mod.sqlite_url = "sqlite://"