assertSame(root, ex.getRootCause());
    }

    /**
     * Verify that {@link #toString()} includes a stack trace when a root cause
     * is present.
     */
    @Test
    @DisplayName("toString with root cause contains stack trace")
    void testToStringWithRootCause() {
        RuntimeException cause = new RuntimeException("boom");
        SmbException ex = new SmbException(0, cause);

      "FINE: Q10000 scheduled after 100 µs: task three",
      "FINE: Q10000 starting              : task one",
      "FINE: Q10000 finished run in   0 µs: task one",
      "FINE: Q10000 starting              : task two",
      "FINE: Q10000 finished run in   0 µs: task two",
      "FINE: Q10000 starting              : task three",
      "FINE: Q10000 finished run in   0 µs: task three",
    )
  }

    public void test_stackTrace() {
        // Test stack trace is properly set
        ResultOffsetExceededException exception = new ResultOffsetExceededException("Stack trace test");

        StackTraceElement[] stackTrace = exception.getStackTrace();
        assertNotNull(stackTrace);
        assertTrue(stackTrace.length > 0);

        // Check that the current test method is in the stack trace
        boolean foundTestMethod = false;

  }

  protected void populate(Multimap<String, Integer> multimap) {
    multimap.put("one", 1);
    multimap.put("two", 2);
    multimap.put("two", 22);
    multimap.put("three", 3);
    multimap.put("three", 33);
    multimap.put("three", 333);
  }

  @Override
  protected String getKeyNotInPopulatedMap() throws UnsupportedOperationException {
    return "zero";
  }

  @Override

        try {
            final Type2Message msg2 = new Type2Message(token);

            if (log.isTraceEnabled()) {
                log.trace(msg2.toString());
                log.trace(Hexdump.toHexString(token));
            }

            this.serverChallenge = msg2.getChallenge();

            if (this.requireKeyExchange) {

        ResourceHolder holder = new ResourceHolder(resourceId, resource, referenceQueue);

        activeResources.put(resourceId, holder);
        totalAllocated.incrementAndGet();

        log.trace("Registered resource: {} ({})", resourceId, resource.getClass().getSimpleName());

        return resourceId;
    }

    /**
     * Mark a resource as closed
     *
     * @param resourceId the resource ID

    }

    public void test_stackTrace() {
        // Test that stack trace is properly set
        DictionaryException exception = new DictionaryException("Stack trace test");

        assertNotNull(exception.getStackTrace());
        assertTrue(exception.getStackTrace().length > 0);

        // Verify that the stack trace contains this test method
        boolean foundTestMethod = false;

    }

    public void test_stackTrace() {
        // Test that stack trace is properly maintained
        String message = "Stack trace test";
        Exception cause = new IllegalArgumentException("Invalid argument");
        ScriptEngineException exception = new ScriptEngineException(message, cause);

        // Verify stack trace exists
        StackTraceElement[] stackTrace = exception.getStackTrace();

#log4j.logger.jcifs.smb.SmbTransportImpl: DEBUG
#log4j.logger.jcifs.util.transport.Transport: DEBUG
#log4j.logger.jcifs.smb.DfsImpl: DEBUG
#log4j.logger.jcifs.smb: DEBUG
#log4j.logger.jcifs.smb.SmbFileOutputStream: TRACE
#log4j.logger.jcifs.smb.SigningDigest: TRACE

	S.Logger.Warn(ctx, s, i...)
}

func (S Tracer) Error(ctx context.Context, s string, i ...interface{}) {
	S.Logger.Error(ctx, s, i...)
}

func (S Tracer) Trace(ctx context.Context, begin time.Time, fc func() (sql string, rowsAffected int64), err error) {
	S.Logger.Trace(ctx, begin, fc, err)
	S.Test(ctx, begin, fc, err)