assertEquals(middleCause, exception.getCause());
        assertEquals(rootCause, exception.getCause().getCause());
    }

    public void test_stackTrace() {
        // Test that stack trace is properly set
        DataStoreException exception = new DataStoreException("Test error");
        StackTraceElement[] stackTrace = exception.getStackTrace();

        assertNotNull(stackTrace);

    @Test
    @DisplayName("Should preserve stack trace")
    void testStackTracePreservation() {
        // When
        RuntimeCIFSException exception = new RuntimeCIFSException("Test exception");

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

        // Should contain this test method in stack trace
        boolean foundTestMethod = false;

# work. That's because the Proguard configuration required to make them work on
# optimized code would preclude lots of optimization, like converting enums
# into ints.

# Throwables uses internal APIs for lazy stack trace resolution
-dontnote sun.misc.SharedSecrets
-keep class sun.misc.SharedSecrets {
  *** getJavaLangAccess(...);
}
-dontnote sun.misc.JavaLangAccess
-keep class sun.misc.JavaLangAccess {
  *** getStackTraceElement(...);

       implementation("com.squareup.okhttp3:logging-interceptor")
    }
```

Maven and JVM Projects
----------------------

OkHttp is published as a Kotlin Multiplatform project. While Gradle handles this automatically,
Maven projects must select between `okhttp-jvm` and `okhttp-android`. The `okhttp` artifact will be empty in
Maven projects.

```xml
<dependencyManagement>
  <dependencies>

                    executionMode = BuildStep.ExecutionMode.ALWAYS
                    scriptContent =
                        "cd testing/distributions-integ-tests/src && ! grep 'org.gradle.test.fixtures.Flaky' -r ."
                }
            }
        }

        val extraParameters =
            functionalTestExtraParameters(
                listOf("FlakyTestQuarantine"),
                os,

                    throw r;
                } catch (SmbException se) {
                    if (log.isTraceEnabled()) {
                        log.trace("Send failed", se);
                        log.trace("Request: " + request);
                        log.trace("Response: " + response);
                    }
                    throw se;
                }
            } finally {
                request.setDigest(null);

    public void release() {
        final long usage = this.usageCount.decrementAndGet();
        if (log.isTraceEnabled()) {
            log.trace("Release transport " + usage + " " + this);
        }

        if (usage == 0) {
            if (log.isTraceEnabled()) {
                log.trace("Transport usage dropped to zero " + this);
            }
        } else if (usage < 0) {

        assertTrue(exception instanceof FessSystemException);
        assertTrue(exception instanceof RuntimeException);
    }

    public void test_suppressionAndStackTrace() {
        // Test that suppression and stack trace are disabled (as per constructor)
        String parentUrl = "http://example.com/parent";
        String url = "http://example.com/child";
        ContentNotFoundException exception = new ContentNotFoundException(parentUrl, url);

This property is sometimes referred to as DRF-SC: data-race-free programs
execute in a sequentially consistent manner.
</p>

<p>
While programmers should write Go programs without data races,
there are limitations to what a Go implementation can do in response to a data race.
An implementation may always react to a data race by reporting the race and terminating the program.

                if (log.isDebugEnabled()) {
                    log.debug("File pointer is at " + this.fp);
                }
            }
            return this.handle;
        }

        log.trace("File already open");
        return this.handle.acquire();
    }

    /**
     * Ensures that the tree connection is established.
     *
     * @return the tree handle