Type2Message.NTLMSSP_NEGOTIATE_UNICODE | Type2Message.NTLMSSP_NEGOTIATE_VERSION, TEST_CHALLENGE, TEST_TARGET);
            byte[] rawMessage = originalMessage.toByteArray();

            // Manually set targetNameOff to a value that makes it too small for context/reserved
            Type2Message.writeULong(rawMessage, 16, 0); // targetNameOff is at byte 16

            // When

    }

    @Test
    void testGetHealthyChannels() throws UnknownHostException {
        assertTrue(channelManager.getHealthyChannels().isEmpty());

        // Add a healthy channel manually for testing
        InetAddress addr = InetAddress.getByName("192.168.1.100");
        NetworkInterfaceInfo localInterface = new NetworkInterfaceInfo(addr, 1000);

   * serial access, it is critical that <b>all</b> access to the backing queue is accomplished
   * through the returned queue.
   *
   * <p>It is imperative that the user manually synchronize on the returned queue when accessing the
   * queue's iterator:
   *
   * {@snippet :
   * Queue<E> queue = Queues.synchronizedQueue(MinMaxPriorityQueue.<E>create());
   * ...

  fun sleep(durationNanos: Long) {
    taskRunner.withLock {
      val sleepUntil = nanoTime + durationNanos
      yieldUntil { nanoTime >= sleepUntil }
    }
  }

  /**
   * Artificially stall until manually resumed by the test thread with [runTasks]. Use this to
   * simulate races in tasks that doesn't have a deterministic sequence.
   */
  fun yield() {
    taskRunner.assertLockNotHeld()
    taskRunner.withLock {

 * methods. This class uses a single thread to execute the service; consider {@link AbstractService}
 * if you would like to manage any threading manually.
 *
 * @author Jesse Wilson
 * @since 1.0
 */
@GwtIncompatible
@J2ktIncompatible
public abstract class AbstractExecutionThreadService implements Service {
  /* use AbstractService for state management */

   * {@code factory}, and the table contents are all serializable.
   *
   * <p>Note: the table assumes complete ownership over of {@code backingMap} and the maps returned
   * by {@code factory}. Those objects should not be manually updated and they should not use soft,
   * weak, or phantom references.
   *
   * @param backingMap place to store the mapping from each row key to its corresponding column key
   *     / value map

   * serial access, it is critical that <b>all</b> access to the backing queue is accomplished
   * through the returned queue.
   *
   * <p>It is imperative that the user manually synchronize on the returned queue when accessing the
   * queue's iterator:
   *
   * {@snippet :
   * Queue<E> queue = Queues.synchronizedQueue(MinMaxPriorityQueue.<E>create());
   * ...

      return standardFirstEntry();
    }

    /*
     * We can't override lastEntry to delegate to standardLastEntry, as it would create an infinite
     * loop. Instead, we test standardLastEntry manually below.
     */

    @Override
    public @Nullable Entry<K, V> pollFirstEntry() {
      return standardPollFirstEntry();
    }

    @Override
    public @Nullable Entry<K, V> pollLastEntry() {

It's acceptable for implementation classes to be written to fit into existing code, but new classes must not instantiate managed properties or implement getters manually.

This is preferred:

```groovy
public interface NewThing {
    Property<String> getSomeProperty()
}
```

This is acceptable:

```groovy
public interface NewThing {

     * customizations.
     *
     * Most TLS clients that connect to hosts on the public Internet should call this method.
     * Otherwise it is necessary to manually prepare a comprehensive set of trusted roots.
     *
     * If the host platform is compromised or misconfigured this may contain untrustworthy root