import org.junit.jupiter.api.Test;

import com.google.common.collect.Lists;

public class MemoryUtilTest extends UnitFessTestCase {

    @Test
    public void test_byteCountToDisplaySize() {
        assertEquals("0bytes", MemoryUtil.byteCountToDisplaySize(0L));
        assertEquals("999bytes", MemoryUtil.byteCountToDisplaySize(999L));
        assertEquals("1000bytes", MemoryUtil.byteCountToDisplaySize(1000L));

     */
    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;
    }

    /**

     *
     * @param name the name of the item
     * @param path the path of the item
     * @param directory true if this item is a directory
     * @param size the size of the item in bytes
     * @param lastModified the last modified timestamp
     * @param encodedId the base64-encoded ID of the item
     */

    /**
     * Uploads an object to storage.
     *
     * @param objectName the name/path for the object
     * @param inputStream the input stream of data to upload
     * @param size the size of the data in bytes
     * @param contentType the MIME type of the content
     */
    void uploadObject(String objectName, InputStream inputStream, long size, String contentType);

    /**
     * Downloads an object from storage.
     *

                .setState(state)//
                .build();
    }

    /**
     * Decodes a Base64 string to bytes.
     *
     * @param base64String the Base64 string to decode
     * @return the decoded bytes, or null if input is null
     */
    protected byte[] decodeBase64(String base64String) {
        if (base64String == null) {
            return null;
        }
        try {

                        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);
        }