.filter(p -> p.toString().endsWith(".adoc"))
                .forEach(file -> {
                    try {
                        // The regex `^\\s*\\[\\[(.*)\\]\\]` looks for lines starting with '[[...]]'
                        // and captures the content within the brackets.
                        Files.readAllLines(file).forEach(line -> {

			return tx2.Scan(&User{}).Error
		})
	})
	if err != nil {
		t.Error(err)
	}

	// method with hooks
	err = DB.Transaction(func(tx1 *gorm.DB) error {
		// callMethod do
		tx2 := tx1.Find(&User{}).Session(&gorm.Session{NewDB: true})
		// trx in hooks
		return tx2.Transaction(func(tx3 *gorm.DB) error {
			return tx3.Where("user_id", user.ID).Delete(&Account{}).Error
		})
	})

    assertTrue(map.isEmpty());
  }

  // ----------------------------------------------------------------
  // Test that interrupts result in RuntimeException, not InterruptedException.
  // Trickier than it looks, because runFinalization swallows interrupts.
  // ----------------------------------------------------------------

  static final class Interruptenator extends Thread {
    final AtomicBoolean shutdown;

        } finally {
          taskRunner.withLock {
            activeThreads--
            startNextTask()
          }
        }
      }
    }
  }

  /**
   * This blocking queue hooks into a fake clock rather than using regular JVM timing for functions
   * like [poll]. It is only usable within task faker tasks.
   */
  private inner class TaskFakerBlockingQueue<T>(
    val delegate: BlockingQueue<T>,

    try {
      finalizeReferentMethod.invoke(reference);
    } catch (Throwable t) {
      logger.log(Level.SEVERE, "Error cleaning up after reference.", t);
    }
    return true;
  }

  /** Looks up FinalizableReference.finalizeReferent() method. */
  private @Nullable Method getFinalizeReferentMethod() {
    Class<?> finalizableReferenceClass = finalizableReferenceClassReference.get();

     */
    @Override
    public boolean verifySignature(final byte[] buffer, final int i, final int size) {
        // observed too that signatures on error responses are sometimes wrong??
        // Looks like the failure case also is just reflecting back the signature we sent

        // with SMB3's negotiation validation it's no longer possible to ignore this (on the validation response)

    suite.addTest(
        MapTestSuiteBuilder.using(
                new TestTypeToInstanceMapGenerator() {
                  // Other tests will verify what real, warning-free usage looks like
                  // but here we have to do some serious fudging
                  @Override
                  @SuppressWarnings({"unchecked", "rawtypes"})

  // Builds a tensor filled with ones with the same shape and dtype as `t`.
  absl::Status BuildOnesLike(const TapeTensor& t,
                             AbstractTensorHandle** result) const override;

  // Looks up the ID of a Gradient.
  int64_t TensorId(AbstractTensorHandle* tensor) const override;

  // Converts a Gradient to a TapeTensor.
  TapeTensor TapeTensorFromGradient(AbstractTensorHandle* g) const override;

        return (context, query, boost) -> filter.execute(context, query, boost, chain);
    }

    /**
     * Creates the default filter chain that executes query commands.
     * This chain looks up the appropriate query command based on the query class name
     * and executes it. If no command is found, throws an InvalidQueryException.
     *
     * @return the default filter chain implementation
     */

    suite.addTest(
        MapTestSuiteBuilder.using(
                new TestTypeToInstanceMapGenerator() {
                  // Other tests will verify what real, warning-free usage looks like
                  // but here we have to do some serious fudging
                  @Override
                  @SuppressWarnings({"unchecked", "rawtypes"})