@Test
        @DisplayName("Should validate constant bit ranges")
        void shouldValidateConstantBitRanges() {
            // File access constants should fit in lower 16 bits (0x0000FFFF)
            assertTrue(ACE.FILE_READ_DATA <= 0x0000FFFF, "FILE_READ_DATA should fit in lower 16 bits");
            assertTrue(ACE.FILE_WRITE_DATA <= 0x0000FFFF, "FILE_WRITE_DATA should fit in lower 16 bits");

         * @param p The process to monitor.
         * @param ist The input stream thread.
         * @param timeout The destruction timeout.
         */
        public ProcessDestroyer(final Process p, final InputStreamThread ist, final long timeout) {
            this.p = p;
            this.ist = ist;
            this.timeout = timeout;
        }

        /**

    }

    /**
     * Converts child URLs using the URL convert helper.
     *
     * @param requestDataList the list of request data to convert
     * @return the converted list of request data
     */
    protected List<RequestData> convertChildUrlList(final List<RequestData> requestDataList) {
        try {
            final UrlConvertHelper urlConvertHelper = crawlerContainer.getComponent("urlConvertHelper");

            }
        }
    }

    /**
     * Starts a new process with the given session ID and command list.
     * Uses default buffer size and no output callback.
     *
     * @param sessionId unique identifier for the process session
     * @param cmdList list of command and arguments to execute
     * @param pbCall callback to configure the ProcessBuilder

import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

    /**
     * The HTTP method for the request.
     */
    protected final Method method;

    /**
     * The list of request parameters.
     */
    protected List<String> paramList;

    /**
     * The list of request headers.
     */
    protected List<String[]> headerList;

    /**
     * The body content of the request.
     */
    protected String body;

    /**

                            final List<?> list = mapper.readValue(jsonBytes, List.class);

                            final List<RequestParameter> result = new ArrayList<>();
                            for (Object item : list) {
                                if (item instanceof List<?> pair) {
                                    if (pair.size() == 2 && pair.get(0) instanceof String name

        /**
         * Get the list of IP addresses for IP change notifications
         *
         * @return list of IP addresses
         */
        public List<String> getIpAddresses() {
            return ipAddresses;
        }

        /**
         * Sets the list of IP addresses for IP change notifications.
         *
         * @param ipAddresses the list of new IP addresses available for the witness service

        // In a real implementation, this would read from configuration
        return 30000; // 30 seconds
    }

    private List<NetworkInterface> getAvailableNetworkInterfaces() {
        try {
            List<NetworkInterface> interfaces = Collections.list(NetworkInterface.getNetworkInterfaces());
            interfaces.removeIf(ni -> {
                try {

            }

            // Verify no overlapping bits
            for (int i = 0; i < capabilities.length; i++) {
                for (int j = i + 1; j < capabilities.length; j++) {
                    assertEquals(0, capabilities[i] & capabilities[j], "Capabilities should not have overlapping bits");
                }
            }
        }

        @Test