return 3;
        }).when(raf).read(any(byte[].class), anyInt(), eq(3));
        assertEquals("abc", raf.readUTF());
    }

    @Test
    @DisplayName("write(boolean/byte): writes single byte")
    void write_oneByteVariants() throws Exception {
        SmbRandomAccessFile raf = spy(newInstance("rw", false, true, false));
        // Intercept the 3-arg write to validate len

      prop(FollowUpDecision::nextRequest).isNotNull()
    }
  }

  /**
   * Auth requires follow-ups. Unlike redirects, the auth follow-up also has a request body. This
   * test makes a single call with two duplex requests!
   */
  @Test
  fun duplexWithAuthChallenge() {
    enableProtocol(Protocol.HTTP_2)
    val credential = basic("jesse", "secret")
    client =
      client

  public static <K, V> ImmutableListMultimap<K, V> of() {
    return (ImmutableListMultimap<K, V>) EmptyImmutableListMultimap.INSTANCE;
  }

  /** Returns an immutable multimap containing a single entry. */
  public static <K, V> ImmutableListMultimap<K, V> of(K k1, V v1) {
    ImmutableListMultimap.Builder<K, V> builder = ImmutableListMultimap.builder();
    builder.put(k1, v1);
    return builder.build();
  }

        }

        @Test
        @DisplayName("Should handle capabilities")
        void testCapabilities() throws Exception {
            // Test single capability
            setPrivateField(response, "capabilities", Smb2TreeConnectResponse.SMB2_SHARE_CAP_DFS);

        response.readParametersWireFormat(buffer, 0, 8);
        assertEquals(status, getStatus(response));
    }

    @Test
    @DisplayName("Test readDataWireFormat with single server")
    void testReadDataWireFormatSingleServer() throws Exception {
        // Prepare test data
        String serverName = "SERVER01";
        int versionMajor = 5;
        int versionMinor = 2;

			break
		}
	}
}

type astContext int

const (
	ctxProg astContext = iota
	ctxEmbedType
	ctxType
	ctxStmt
	ctxExpr
	ctxField
	ctxParam
	ctxAssign2 // assignment of a single expression to two variables
	ctxSwitch
	ctxTypeSwitch
	ctxFile
	ctxDecl
	ctxSpec
	ctxDefer
	ctxCall  // any function call other than ctxCall2

     */
    protected String getResultDataHeader() {
        // TODO support other type
        return "<?xml version=\"1.0\"?>\n<doc>\n";
    }

    /**
     * Returns the body of the result data for a single value.
     * @param name The name of the field.
     * @param value The value of the field.
     * @return The result data body.
     */
    protected String getResultDataBody(final String name, final String value) {

	if err != nil {
		h.currentStatus.Items = nil

		bugLogIf(h.ctx, err)
		return nil, ErrInternalError
	}

	h.currentStatus.Items = nil

	return jbytes, ErrNone
}

// healSource denotes single entity and heal option.
type healSource struct {
	bucket    string
	object    string
	versionID string
	noWait    bool             // a non blocking call, if task queue is full return right away.

    assertThrows(IllegalStateException.class, () -> manager.startAsync().awaitHealthy());
    assertTrue(listener.stoppedCalled);
  }

  /**
   * This covers a bug where listener.healthy would get called when a single service failed during
   * startup (it occurred in more complicated cases also).
   */
  public void testFailStart_singleServiceCallsHealthy() {
    Service a = new FailStartService();

            len += pad8(bufferIndex);
        } else if (compound && this.nextCommand == 0 && this.readSize > 0) {
            // Apply compound response handling as per MS-SMB2 3.2.5.1.9 - correct for both compound and single responses
            // 3.2.5.1.9 Handling Compounded Responses
            // The final response in the compounded response chain will have NextCommand equal to 0,