// If no exception, verify it handles negative as expected
        } catch (Exception e) {
            // Expected for negative values
        }

        // Test boundary values
        assertEquals("1bytes", MemoryUtil.byteCountToDisplaySize(1L));
        assertEquals("999bytes", MemoryUtil.byteCountToDisplaySize(999L));

        // Test very large values close to EB boundary

     */
    public Object fromBinaryToObject(final byte[] bytes) {
        final String serializer = getSerializerType();
        return switch (serializer) {
        case KRYO -> deserializeWithKryo(bytes);
        case JAVABIN -> SerializeUtil.fromBinaryToObject(bytes);
        default -> throw new IllegalArgumentException("Unexpected value: " + serializer);
        };
    }

    /**

                return;
            }
            final byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
            try (OutputStream out = Files.newOutputStream(filePath, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING,
                    LinkOption.NOFOLLOW_LINKS)) {
                out.write(bytes);
            }
        } catch (final IOException e) {

     */
    @Test
    public void test_serializationConsistency() {
        String original = "Consistency Test";

        byte[] serialized1 = serializer.fromObjectToBinary(original);
        byte[] serialized2 = serializer.fromObjectToBinary(original);

        // Note: Serialized bytes may not be identical due to metadata,
        // but deserialization should produce the same result

        return new JakartaServletDiskFileUpload(fileItemFactory) {
            @Override
            public byte[] getBoundary(final String contentType) { // for security
                final byte[] boundary = super.getBoundary(contentType);
                checkBoundarySize(contentType, boundary);
                return boundary;
            }
        };
    }

        }
    }

    /**
     * Checks if the byte array contains UTF-8 BOM (Byte Order Mark).
     *
     * @param b the byte array to check
     * @return true if the bytes represent UTF-8 BOM, false otherwise
     */
    private boolean isUtf8BomBytes(final byte[] b) {
        return b[0] == (byte) 0xEF && b[1] == (byte) 0xBB && b[2] == (byte) 0xBF;
    }

    /**

                        return responseDataMap;
                    } catch (final Exception e) {
                        throw new CrawlerSystemException("Could not create an instance from bytes.", e);
                    }
                }
            }
            return null;
        } catch (final Exception e) {
            throw new CrawlingAccessException("Failed to parse " + url, e);
        }

            public String getAppCipherAlgorithm() {
                return "AES";
            }

            @Override
            public String getAppCipherKey() {
                return "1234567890123456"; // 16 bytes for AES
            }
        });

        // Create test cipher - use proper constructor with simple implementation
        InvertibleCryptographer cookieCipher = new InvertibleCryptographer("AES", "1234567890123456", null) {

    }

    private static String readFully(InputStream inputStream) throws IOException {
        try (InputStream input = inputStream; ByteArrayOutputStream out = new ByteArrayOutputStream()) {
            byte[] buf = new byte[8192];
            int read;
            while ((read = input.read(buf)) >= 0) {
                out.write(buf, 0, read);
            }
            return out.toString(StandardCharsets.UTF_8.name());

                "This is test data for compression that should be long enough to actually compress effectively when using gzip compression algorithm";
        byte[] originalBytes = testData.getBytes();

        byte[] compressed = searchHelper.gzipCompress(originalBytes);
        byte[] decompressed = searchHelper.gzipDecompress(compressed);

        assertEquals(testData, new String(decompressed));