}

	level22 := &Level2{
		Value:   "Level2-2",
		Level1s: []*Level1{level1Zh, level1En},
	}

	wants := []*Level3{
		{
			Value:  "Level3-1",
			Level2: level21,
		},
		{
			Value:  "Level3-2",
			Level2: level22,
		},
		{
			Value:  "Level3-3",
			Level2: level21,
		},
	}

	for _, want := range wants {

        // Test deeply nested exception causes
        Exception level3 = new Exception("Level 3: Database connection failed");
        Exception level2 = new Exception("Level 2: User lookup failed", level3);
        Exception level1 = new Exception("Level 1: Authentication service error", level2);
        SsoProcessException topLevel = new SsoProcessException("SSO process failed", level1);

        // Verify the chain

    public void test_evaluate_withNestedExpressions() {
        String template = "${level1.level2.value}";
        Map<String, Object> paramMap = new HashMap<>();
        Map<String, Object> level2 = new HashMap<>();
        level2.put("value", "nested");
        Map<String, Object> level1 = new HashMap<>();
        level1.put("level2", level2);
        paramMap.put("level1", level1);

   * Returns the ancestor of the current domain at the given number of levels "higher" (rightward)
   * in the subdomain list. The number of levels must be non-negative, and less than {@code N-1},
   * where {@code N} is the number of parts in the domain.
   *
   * <p>TODO: Reasonable candidate for addition to public API.
   */
  private InternetDomainName ancestor(int levels) {

    // optimistically fill index position with elements from lower levels,
    // moving the hole down. In most cases this reduces the number of
    // comparisons with toTrickle, but in some cases we will need to bubble it
    // all the way up again.
    int vacated = heap.fillHoleAt(index);
    // Try to see if toTrickle can be bubbled up min levels.
    int bubbledTo = heap.bubbleUpAlternatingLevels(vacated, toTrickle);

        // Should read nothing (returns 0)
        assertEquals(0, read);
    }

    @Test
    void testMapInformationLevel() {
        // Test valid information levels
        assertEquals(0x0101, Trans2QueryPathInformation.mapInformationLevel(FileInformation.FILE_BASIC_INFO));
        assertEquals(0x0102, Trans2QueryPathInformation.mapInformationLevel(FileInformation.FILE_STANDARD_INFO));

    // optimistically fill index position with elements from lower levels,
    // moving the hole down. In most cases this reduces the number of
    // comparisons with toTrickle, but in some cases we will need to bubble it
    // all the way up again.
    int vacated = heap.fillHoleAt(index);
    // Try to see if toTrickle can be bubbled up min levels.
    int bubbledTo = heap.bubbleUpAlternatingLevels(vacated, toTrickle);

            assertEquals("Expected structureSize = 24", exception.getMessage());
        }

        @ParameterizedTest
        @DisplayName("Should read different oplock levels correctly")
        @ValueSource(bytes = { 0x00, 0x01, 0x02, 0x08, (byte) 0xFF })
        void testReadDifferentOplockLevels(byte oplockLevel) throws Exception {

            assertTrue(s);
        }
    }

    @DisplayName("Test exception handling for invalid information levels")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 2, 4, 5, 6, 8, 100, -2, -100, Integer.MIN_VALUE, Integer.MAX_VALUE })
    void testInvalidInformationLevels(int invalidLevel) {
        // Skip valid levels

    public void test_nestedExceptions() {
        // Test nested exception handling
        Exception level3 = new RuntimeException("Level 3 error");
        Exception level2 = new IllegalStateException("Level 2 error", level3);
        Exception level1 = new IOException("Level 1 error", level2);
        SsoLoginException exception = new SsoLoginException("Top level SSO error", level1);

        assertEquals("Top level SSO error", exception.getMessage());