assertEquals("59.999 s", CLIReportingUtils.formatDuration(60 * 1000 - 1));
        assertEquals("01:00 min", CLIReportingUtils.formatDuration(60 * 1000));
        assertEquals("59:59 min", CLIReportingUtils.formatDuration(60 * 60 * 1000 - 1));
        assertEquals("01:00 h", CLIReportingUtils.formatDuration(60 * 60 * 1000));
        assertEquals("23:59 h", CLIReportingUtils.formatDuration(24 * 60 * 60 * 1000 - 1));

    multipart_incorrect_install_error,
    multipart_not_installed_error,
)


def test_incorrect_multipart_installed_form(monkeypatch):
    monkeypatch.setattr("python_multipart.__version__", "0.0.12")
    with warnings.catch_warnings(record=True):
        warnings.simplefilter("always")
        monkeypatch.delattr("multipart.multipart.parse_options_header", raising=False)

            response.setDigest(mockDigest);
            when(mockDigest.verify(buffer, 0, 100, 0, response)).thenReturn(false);

            boolean result = response.verifySignature(buffer, 0, 100);

            assertTrue(result);
            assertFalse(response.isVerifyFailed());
        }

        @Test
        @DisplayName("Should handle signature verification failure")

            processor.init();

            // Should handle exception gracefully and return results from working searcher
            final List<Map<String, Object>> results = processor.search("*", new TestSearchRequestParams(0, 10, 0), OptionalThing.empty());
            assertNotNull(results);
        }
    }

    /**
     * Test handling of searcher that throws FessSystemException.
     */
    @Test

        byte[] rawData = new byte[48]; // 8 (size/zero) + 8 (customData) + 32 (machineId)
        // Simulate some data
        rawData[0] = 48; // size
        rawData[16] = 0x01; // machineId start
        rawData[17] = 0x02;

        AvSingleHost avSingleHost = new AvSingleHost(rawData);

        assertNotNull(avSingleHost);
        assertEquals(AvPair.MsvAvSingleHost, avSingleHost.getType());

            when(mockConfig.isRequireSecureNegotiate()).thenReturn(true);
            when(mockDigest.verify(buffer, 0, 100, 0, echoResponse)).thenReturn(false);

            boolean result = echoResponse.verifySignature(buffer, 0, 100);

            assertTrue(result);
            assertFalse(echoResponse.isVerifyFailed());
            verify(mockDigest).verify(buffer, 0, 100, 0, echoResponse);
        }

        @Test

        assertFalse(key.isZero());
    }

    @Test
    @DisplayName("Should create lease key from byte array")
    void testLeaseKeyFromBytes() {
        byte[] testBytes = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x10 };

        Smb2LeaseKey key = new Smb2LeaseKey(testBytes);

        assertArrayEquals(testBytes, key.getKey());

        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };
        ByteEncodable encodable = new ByteEncodable(data, 1, 3);

        // Verify size
        assertEquals(3, encodable.size(), "Size should be equal to the specified length");
    }

    @Test
    void testEncodeBasic() {
        // Test basic encoding
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };

  public void testCollisionsDueToIncorrectSignExtension() {
    byte[] col1 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0x80};
    byte[] col2 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0x81};
    byte[] col3 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0xff};

    ImmutableSet<HashCode> hashCodes =
        ImmutableSet.of(

  public void testCollisionsDueToIncorrectSignExtension() {
    byte[] col1 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0x80};
    byte[] col2 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0x81};
    byte[] col3 = new byte[] {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, (byte) 0xff};

    ImmutableSet<HashCode> hashCodes =
        ImmutableSet.of(