Thread[] threads = new Thread[5];
        for (int i = 0; i < threads.length; i++) {
            threads[i] = new Thread(() -> failover.handleFailure(failedChannel, error));
            threads[i].start();
        }

        // Wait for all threads to complete
        for (Thread thread : threads) {
            thread.join(1000);
        }

                channelManager.getChannels();
                channelManager.getHealthyChannels();
                channelManager.getLoadBalancer();
            });
            threads[i].start();
        }

        for (Thread thread : threads) {
            thread.join(1000);
        }

        // Should complete without exceptions
    }

 *  * **b3a**: b3 + 0x80
 *  * **b2b3**: (b2 << 7) + b3
 *
 * b0
 * --
 *
 * The inclusive start of the range. We get the first 14 bits of this code point from the section
 * and the last 7 bits from this byte.
 *
 * The end of the range is not encoded, but can be inferred by looking at the start of the range
 * that follows.
 *
 * b1
 * --
 *

        assertEquals(3, NtlmMessage.readUShort(dest, 2), "Length field must be 3 again");
        assertEquals(8, NtlmMessage.readULong(dest, 4), "Offset must point to payload start");
        byte[] actualPayload = new byte[payload.length];
        System.arraycopy(dest, 8, actualPayload, 0, payload.length);
        assertArrayEquals(payload, actualPayload, "Payload copy must match");
    }

              while (!shutdown.get()) {
                interruptee.interrupt();
                Thread.yield();
              }
            }
          });
      this.shutdown = shutdown;
      start();
    }

    @SuppressWarnings("ThreadPriorityCheck") // TODO: b/175898629 - Consider onSpinWait.
    void shutdown() {
      shutdown.set(true);
      while (this.isAlive()) {
        Thread.yield();

                        exceptions.add(e);
                    }
                } finally {
                    endLatch.countDown();
                }
            });
        }

        // Start all threads
        startLatch.countDown();

        // Wait for completion
        assertTrue(endLatch.await(30, TimeUnit.SECONDS), "All threads should complete");
        executor.shutdown();

                    digest.sign(dataArrays[index], 0, dataArrays[index].length, request, response);
                });
            }

            for (Thread t : threads) {
                t.start();
            }
            for (Thread t : threads) {
                t.join();
            }

            // Verify all arrays were signed
            for (byte[] arr : dataArrays) {

    val subtype: String = mediaType.subtype()
    val parse: MediaType? = MediaType.parse("")
  }

  @Test @Disabled
  fun mockResponse() {
    val mockResponse = MockResponse()
    var status: String = mockResponse.getStatus()
    var headers: Headers = mockResponse.getHeaders()
    var trailers: Headers = mockResponse.getTrailers()
    var socketPolicy: SocketPolicy = mockResponse.getSocketPolicy()

    void toStringContainsKeyData() {
        SmbComNTCreateAndX req = createRequest(0, 0);
        String str = req.toString();
        assertTrue(str.startsWith("SmbComNTCreateAndX["), "toString should start with class name");
        assertTrue(str.contains("name=test.txt"), "The file name should appear");
        // securityFlags are set to 0x03 – verify hex sequence

      --add-opens java.base/java.lang=ALL-UNNAMED
      --add-opens java.base/java.util=ALL-UNNAMED
      --add-opens java.base/sun.security.jca=ALL-UNNAMED
    </test.add.opens>
    <module.status>integration</module.status>
    <variant.jvmEnvironment>android</variant.jvmEnvironment>
    <variant.jvmEnvironmentVariantName>android</variant.jvmEnvironmentVariantName>