java.lang.reflect.Method[] methods = SystemUtil.class.getDeclaredMethods();
        for (java.lang.reflect.Method method : methods) {
            if (!method.isSynthetic()) { // Ignore compiler-generated methods
                assertTrue("Method " + method.getName() + " should be static", java.lang.reflect.Modifier.isStatic(method.getModifiers()));
            }
        }
    }

    @Test

        if (paramMap.containsKey(URL_EXCLUDE_PATTERN)) {
            if (paramMap.get(URL_EXCLUDE_PATTERN) instanceof final String value) {
                final Pattern pattern = Pattern.compile(value);
                paramMap.put(URL_EXCLUDE_PATTERN, pattern);
                if (logger.isDebugEnabled()) {
                    logger.debug("Using exclude pattern: {}", pattern);
                }
            }

                + "//malicious.py";
        assertEquals(expectedPath, pythonJob.getPyFilePath());
    }

    // Test getPyFilePath with complex directory traversal
    @Test
    public void test_getPyFilePath_withComplexDirectoryTraversal() {
        pythonJob.filename("../test/../../../etc/passwd");

      </extension>
    </inspection_tool>
    <inspection_tool class="SSBasedInspection" enabled="true" level="WARNING" enabled_by_default="true">

        // Assert
        assertEquals("Status of test-cluster is changed to RED.", result);
        // Note: Notification sending is tested but we don't verify the mock since it uses complex callback mechanism
    }

    // Test state change with empty notification addresses
    @Test
    public void test_execute_stateChangeEmptyNotificationAddresses() {
        // Setup mock components

        PrunedTag anotherTagWithNulls = new PrunedTag("div");
        assertTrue(tagWithNulls.equals(anotherTagWithNulls));
    }

    @Test
    public void test_parse_complexCombinations() {
        // Test complex parsing combinations
        PrunedTag[] tags = PrunedTag.parse("div[data-toggle=modal].modal#main-modal");
        assertEquals(1, tags.length);
        PrunedTag tag = tags[0];

    }

    @Test
    public void test_constructorWithThrowableCause_NestedErrorAndException() {
        // Test with nested Error and Exception
        String message = "Complex error during thumbnail generation";
        Exception innerException = new IllegalArgumentException("Invalid argument");
        Error middleError = new AssertionError("Assertion failed", innerException);

        assertEquals("Map contents should match", original, deserializedMap);
    }

    /**
     * Test serialization and deserialization of complex nested object
     */
    @Test
    public void test_serializeDeserialize_complexObject() {
        Map<String, Object> original = new HashMap<>();
        original.put("string", "test");

        assertNotNull(dataStoreParams.get("camelCaseKey"));

        dataStoreParams.put("snake_case_key", "value2");
        assertNotNull(dataStoreParams.get("snake_case_key"));
    }

    // Test with complex object values
    @Test
    public void test_complexObjectValues() {
        Map<String, String> complexObject = new HashMap<>();
        complexObject.put("nested", "value");

        // "other" parameter is missing

        Object result = scriptEngine.evaluate(template, paramMap);
        assertEquals("Hello Bob and ${other}", result);
    }

    // Test evaluate method with complex object as parameter
    @Test
    public void test_evaluate_withComplexObject() {
        String template = "User: ${user.name}, Age: ${user.age}";
        Map<String, Object> paramMap = new HashMap<>();