assertEquals(longMessage, exception.getMessage());
        assertNull(exception.getCause());
    }

    @Test
    public void test_getCause_withNestedExceptions() {
        // Test deeply nested exception causes
        Exception level3 = new Exception("Level 3: Database connection failed");
        Exception level2 = new Exception("Level 2: User lookup failed", level3);

        System.setProperty("var2", "value2");

        String value = "${var1}-${var2}";
        assertEquals("value1-value2", ResourceUtil.resolve(value));

        // Test nested-like patterns (but not actual nesting)
        value = "${var1${var2}}"; // The ${var2} part gets replaced first
        assertEquals("${var1value2}", ResourceUtil.resolve(value));

```Python
# Some Python code
```

### Triple backticks inside quadruple backticks { #triple-backticks-inside-quadruple-backticks }

Comments inside nested code block will NOT be preserved.

````
Here is a code block with quadruple backticks that contains triple backticks inside:

```python
# This is a sample Python code block
def hello_world():

        assertEquals(message, exception.getMessage());
        assertNull(exception.getCause());
    }

    @Test
    public void test_constructor_withNestedCause() {
        // Test with nested exception causes
        Exception rootCause = new IllegalArgumentException("Root cause");
        Exception middleCause = new IllegalStateException("Middle cause", rootCause);

    ASSERT_EQ(errors::OK, s.code()) << s.message();
    ctx.reset(ctx_raw);
  }

  AbstractTensorHandlePtr t;
  {
    AbstractTensorHandle* x_raw = nullptr;
    absl::Status s =
        TestScalarTensorHandle<float, TF_FLOAT>(ctx.get(), 1.0f, &x_raw);
    ASSERT_EQ(errors::OK, s.code()) << s.message();
    t.reset(x_raw);
  }

  AbstractOperationPtr check_numerics_op(ctx->CreateOperation());

    public String id;

    /**
     * Default constructor.
     */
    public StemmerOverridePager() {
        // Default constructor
    }

    /**
     * Clears all pagination state and resets to default values.
     */
    public void clear() {
        allRecordCount = 0;
        allPageCount = 0;
        existPrePage = false;
        existNextPage = false;
        pageSize = getDefaultPageSize();

    public String versionNo;

    /**
     * Default constructor for BoostDocPager.
     */
    public BoostDocPager() {
        // Default constructor
    }

    /**
     * Clears all search criteria and resets pagination settings.
     */
    public void clear() {
        allRecordCount = 0;
        allPageCount = 0;
        existPrePage = false;
        existNextPage = false;
        pageSize = getDefaultPageSize();

    }

    // Tests for atomic file operations (TOCTOU fix)

    @Test
    public void test_createDirectories_nestedPath() throws Exception {
        // Test that Files.createDirectories works correctly for nested paths
        Path tempDir = Files.createTempDirectory("toctou_test");
        try {
            Path nestedPath = tempDir.resolve("level1").resolve("level2").resolve("level3");

            throw new SMBProtocolDecodingException("Expected structureSize = 60");
        }
        this.closeFlags = SMBUtil.readInt2(buffer, bufferIndex + 2);
        bufferIndex += 4;
        bufferIndex += 4; // Reserved
        this.creationTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;
        this.lastAccessTime = SMBUtil.readTime(buffer, bufferIndex);
        bufferIndex += 8;

	// DisableForeignKeyConstraintWhenMigrating
	DisableForeignKeyConstraintWhenMigrating bool
	// IgnoreRelationshipsWhenMigrating
	IgnoreRelationshipsWhenMigrating bool
	// DisableNestedTransaction disable nested transaction
	DisableNestedTransaction bool
	// AllowGlobalUpdate allow global update
	AllowGlobalUpdate bool
	// QueryFields executes the SQL query with all fields of the table
	QueryFields bool