// First execution
        String result1 = aggregateLogJob.execute();
        assertNotNull(result1);
        assertTrue(result1.contains("Error 1"));

        // Second execution
        String result2 = aggregateLogJob.execute();
        assertNotNull(result2);
        assertTrue(result2.contains("Error 2"));

        // Results should be independent
        assertFalse(result1.equals(result2));
    }

        Object result1 = scriptExecutor.execute("testengine", "script1");
        assertEquals("processed: script1", result1);

        Object result2 = scriptExecutor.execute("TESTENGINE", "script2");
        assertEquals("processed: script2", result2);

        Object result3 = scriptExecutor.execute("TestEngine", "script3");
        assertEquals("processed: script3", result3);
    }

            assertEquals(result1.get(i), result2.get(i));
            assertEquals(result2.get(i), result3.get(i));
        }

        // Verify content is correct
        assertEquals(2, result1.size());
        assertEquals(mockNotifyInfo1, result1.get(0));
        assertEquals(mockNotifyInfo2, result1.get(1));
    }

        for (byte b : TEST_DATA) {
            hmac2.engineUpdate(b);
        }

        // Both should produce the same result
        byte[] result1 = hmac1.engineDigest();
        byte[] result2 = hmac2.engineDigest();

        assertArrayEquals(result1, result2);
    }

    @Test
    void testHMACT64WithKnownTestVector() throws NoSuchAlgorithmException {
        // Test with known test vector

        PagingList<CharMappingItem> result1 = charMappingFile.selectList(0, 10);
        assertEquals(3, result1.size());
        assertEquals(3, result1.getAllRecordCount());
        assertEquals(1, result1.getAllPageCount());

        // Get first two items
        PagingList<CharMappingItem> result2 = charMappingFile.selectList(0, 2);
        assertEquals(2, result2.size());
        assertEquals(3, result2.getAllRecordCount());

        String result = popularWordHelper.getCacheKey(seed, tags, roles, fields, excludes);

        assertNotNull(result);
        assertTrue(result.contains("test_seed"));
        assertTrue(result.contains("tag1tag2"));
        assertTrue(result.contains("role1role2"));
        assertTrue(result.contains("field1field2"));
        assertTrue(result.contains("exclude1exclude2"));

        // Act
        int result1 = nodeStatusRequest.writeBodyWireFormat(dst, 0);
        int result2 = nodeStatusRequest.writeBodyWireFormat(dst, 50);
        int result3 = nodeStatusRequest.writeBodyWireFormat(dst, 100);

        // Assert
        assertEquals(result1, result2);
        assertEquals(result2, result3);
        assertTrue(result1 > 0);
    }

    @Test

        FuzzyQuery fuzzyQuery1 = new FuzzyQuery(term1, 1);
        QueryBuilder result1 = fuzzyQueryCommand.convertFuzzyQuery(context, fuzzyQuery1, 1.0f);
        assertNotNull(result1);
        assertTrue(result1 instanceof FuzzyQueryBuilder);
        FuzzyQueryBuilder fqb1 = (FuzzyQueryBuilder) result1;
        assertEquals("1", fqb1.fuzziness().asString());

        // Test with max edits = 2

        String result1 = provider1.toString();
        String result2 = provider2.toString();

        // Both should have the same format structure
        assertTrue(result1.startsWith("FessUserTimeZoneProcessProvider:{"));
        assertTrue(result2.startsWith("FessUserTimeZoneProcessProvider:{"));

        // But different hash codes
        assertFalse(result1.equals(result2));
    }

                .build();

        LogEvent result1 = policy.rewrite(event1);
        LogEvent result2 = policy.rewrite(event2);
        LogEvent result3 = policy.rewrite(event3);

        assertEquals(Level.WARN, result1.getLevel());
        assertEquals(Level.WARN, result2.getLevel());
        assertEquals(Level.WARN, result3.getLevel());
    }