assertEquals("message should be default", "{org.lastaflute.validator.constraints.UriType.message}", annotation.message());
        assertEquals("groups should be empty", 0, annotation.groups().length);
        assertEquals("payload should be empty", 0, annotation.payload().length);
    }

    // Test annotation on field with FILE protocol
    @Test

        assertNotNull(annotation, "Annotation should be present on field");
        assertEquals("Default message should match", "{jakarta.validation.constraints.Size.message}", getDefaultMessage());
        assertEquals("Default groups should be empty", 0, getDefaultGroups().length);
        assertEquals("Default payload should be empty", 0, getDefaultPayload().length);
        assertEquals("Default minKey should be empty", StringUtil.EMPTY, getDefaultMinKey());

        assertTrue(nameIndex > 0, "Should contain name element");
        assertTrue(descriptionIndex > 0, "Should contain description element");
        assertTrue(propertiesIndex > 0, "Should contain properties element");

        // According to ELEMENT_ORDER: name should come before description, and properties should come much later
        assertTrue(nameIndex < descriptionIndex, "name should come before description");

        assertFalse("Should capture some thread dump output", capturedOutput.isEmpty());

        // Verify format - should contain "Thread:" entries
        boolean hasThreadEntry = capturedOutput.stream().anyMatch(line -> line.startsWith("Thread:"));
        assertTrue("Should contain Thread: entries", hasThreadEntry);

        // Verify format - should contain stack trace entries

        assertEquals("Double should match", 3.14, deserialized.get("double"));
        assertEquals("Boolean should match", true, deserialized.get("boolean"));
        assertNotNull(deserialized.get("date"), "Date should not be null");
        assertNotNull(deserialized.get("list"), "List should not be null");
        assertNotNull(deserialized.get("nestedMap"), "Nested map should not be null");

        String queryString = result.toString();
        assertTrue("Should contain tag1", queryString.contains("tag1"));
        assertTrue("Should contain tag2", queryString.contains("tag2"));
        assertTrue("Should contain tag3", queryString.contains("tag3"));
        // Should be minimum_should_match = 1 (OR logic)
        assertTrue("Should use should clauses", queryString.contains("should"));
    }

    @Test

            assertNotNull("Resource should exist", is);
            contentNew = new String(is.readAllBytes(), StandardCharsets.UTF_8);
        }

        // Verify content is valid JSON
        assertTrue("Content should start with {", contentNew.trim().startsWith("{"));
        assertTrue("Content should end with }", contentNew.trim().endsWith("}"));
        assertTrue("Content should be substantial", contentNew.length() > 100);

        assertTrue(TimeoutTarget.class.isAssignableFrom(SystemMonitorTarget.class), "SystemMonitorTarget should implement TimeoutTarget");
    }

    @Test
    public void test_constructor() {
        assertNotNull(target, "Constructor should create instance");
        assertTrue(target instanceof SystemMonitorTarget, "Instance should be of correct type");

		t.Fatalf("Should find 1 tags after Delete")
	}

	if DB.Model(&blog).Association("Tags").Count() != 1 {
		t.Fatalf("Blog should has three tags after Delete")
	}

	DB.Model(&blog).Association("Tags").Delete(tag3)
	var tags4 []Tag
	DB.Model(&blog).Association("Tags").Find(&tags4)
	if !compareTags(tags4, []string{"tag6"}) {
		t.Fatalf("Tag should not be deleted when Delete with a unrelated tag")

        final List<String> indices = (List<String>) method.invoke(suggester, aliasName);

        assertNotNull("Indices list should not be null", indices);
        assertEquals("Should find exactly two indices", 2, indices.size());
        assertTrue("Should contain first index", indices.contains(index1));
        assertTrue("Should contain second index", indices.contains(index2));

        // Cleanup