@Test
  public void testGetFinalizerUrl() {
    assertThat(getClass().getResource("internal/Finalizer.class")).isNotNull();
  }

  @Test
  public void testFinalizeClassHasNoNestedClasses() throws Exception {
    // Ensure that the Finalizer class has no nested classes.
    // See https://github.com/google/guava/issues/1505
    assertThat(Finalizer.class.getDeclaredClasses()).isEmpty();
  }

    }

    /**
     * Finalizes and removes the preauth integrity context for a session.
     *
     * @param sessionId the session identifier
     */
    public void finalizeSession(String sessionId) {
        PreauthIntegrityContext context = sessionContexts.remove(sessionId);
        if (context != null) {
            context.invalidate();

        state["/async_raise"] = "asyncgen raise finalized"


def generator_state_try(state: dict[str, str] = Depends(get_state)):
    state["/sync_raise"] = "generator raise started"
    try:
        yield state["/sync_raise"]
    except SyncDependencyError:
        errors.append("/sync_raise")
        raise
    finally:
        state["/sync_raise"] = "generator raise finalized"

  public void testAwait_countDownLatch() {
    CountDownLatch latch = new CountDownLatch(1);
    Object unused =
        new Object() {
          @SuppressWarnings({"removal", "Finalize"}) // b/487687332
          @Override
          protected void finalize() {
            latch.countDown();
          }
        };
    unused = null; // Hint to the JIT that unused is unreachable
    GcFinalization.await(latch);

  public void testAwait_countDownLatch() {
    CountDownLatch latch = new CountDownLatch(1);
    Object unused =
        new Object() {
          @SuppressWarnings({"removal", "Finalize"}) // b/487687332
          @Override
          protected void finalize() {
            latch.countDown();
          }
        };
    unused = null; // Hint to the JIT that unused is unreachable
    GcFinalization.await(latch);

    assertThat(frqC).isNotSameInstanceAs(sepFrqC);
    // Check the assumptions above.

    // FRQ tries to load the Finalizer class (for the reference-collecting thread) in a few ways.
    // If the class is accessible to the system ClassLoader (ClassLoader.getSystemClassLoader())
    // then FRQ does not bother to load Finalizer.class through a separate ClassLoader. That happens

    assertThat(frqC).isNotSameInstanceAs(sepFrqC);
    // Check the assumptions above.

    // FRQ tries to load the Finalizer class (for the reference-collecting thread) in a few ways.
    // If the class is accessible to the system ClassLoader (ClassLoader.getSystemClassLoader())
    // then FRQ does not bother to load Finalizer.class through a separate ClassLoader. That happens

    }

    @Test
    @DisplayName("finalize() invokes checkRelease exactly once")
    void finalize_invokes_checkRelease() throws Throwable {
        // Arrange: spy to verify internal interaction with checkRelease()
        CIFSContext ctx = mock(CIFSContext.class);
        SmbTreeConnectionTrace trace = Mockito.spy(new SmbTreeConnectionTrace(ctx));

        // Act: directly invoke finalize to simulate GC finalization path

    }

    public String getFileContents(File file, String encoding) throws IOException {
        return FileUtils.fileRead(file, encoding);
    }

    protected void finalize() throws Throwable {
        maybeWarnAboutCleanUp();

        super.finalize();
    }

    public File createFile(String filename, String content, String encoding) throws IOException {
        File dir = createTempDir();

                                    const PartialTensorShape& shape,
                                    TracingTensorHandle**) = 0;

  // Finalize this context and make a function out of it. The context is in a
  // invalid state after this call and must be destroyed.
  virtual absl::Status Finalize(OutputList* outputs, AbstractFunction**) = 0;

  // For LLVM style RTTI.
  static bool classof(const AbstractContext* ptr) {