void testHaveCapabilityMultipleFlags() {
        // Arrange
        int cap1 = 0x00000001;
        int cap2 = 0x00000002;
        int cap3 = 0x00000004;
        when(negotiationResponse.haveCapabilitiy(cap1)).thenReturn(true);
        when(negotiationResponse.haveCapabilitiy(cap2)).thenReturn(false);
        when(negotiationResponse.haveCapabilitiy(cap3)).thenReturn(true);

        // Act & Assert

	buf := make([]byte, 1024)
	b.Write(buf[0:1])
	var cap0 int
	for i := 0; i < 5<<10; i++ {
		b.Write(buf)
		b.Read(buf)
		if i == 0 {
			cap0 = b.Cap()
		}
	}
	cap1 := b.Cap()
	// (*Buffer).grow allows for 2x capacity slop before sliding,
	// so set our error threshold at 3x.
	if cap1 > cap0*3 {
		t.Errorf("buffer cap = %d; too big (grew from %d)", cap1, cap0)
	}
}

    @DisplayName("hasCapability(cap): returns configured value and captures argument across edge caps")
    void hasCapability_variousCaps_returnsTrue_andCapturesArgument(int cap) throws Exception {
        // Arrange: stub to return true regardless of input
        when(handle.hasCapability(anyInt())).thenReturn(true);

        // Act
        boolean result = handle.hasCapability(cap);

    @ValueSource(ints = { -1, 0, 1, 1024 })
    void hasCapability_variousCaps(int cap) throws SmbException {
        when(transport.hasCapability(anyInt())).thenAnswer(inv -> ((int) inv.getArgument(0)) >= 0);

        boolean result = transport.hasCapability(cap);

        assertEquals(cap >= 0, result);
        verify(transport, times(1)).hasCapability(cap);
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbNegotiationResponse#haveCapabilitiy(int)
     */
    @Override
    public boolean haveCapabilitiy(final int cap) {
        return (this.commonCapabilities & cap) == cap;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.SmbNegotiationResponse#isDFSSupported()
     */
    @Override
    public boolean isDFSSupported() {

  EXPECT_EQ(22, product[3]);
  TF_DeleteStatus(status);
}
TEST(CAPI, Executor_MatMul_CPU) { Executor_MatMul_CPU(false); }
TEST(CAPI, Executor_MatMul_CPUAsync) { Executor_MatMul_CPU(true); }

void Deleter(void* data, size_t unused, void* tensor_handle) {
  TFE_DeleteTensorHandle(static_cast<TFE_TensorHandle*>(tensor_handle));
}

TEST(CAPI, TensorHandleOnDeviceMemory) {
  TF_Status* status = TF_NewStatus();

                                       remote_func_outputs, has_packed_input);
}

TEST(CAPI, RemoteExecuteSilentCopiesAsyncFunc) {
  TestRemoteExecuteSilentCopiesFunc(/*async=*/true, /*remote=*/true,
                                    /*heavy_load_on_streaming_rpc=*/false);
}
TEST(CAPI, RemoteExecuteSilentCopiesFuncRemoteOutputs) {
  TestRemoteExecuteSilentCopiesFunc(/*async=*/false, /*remote=*/true,

  TFE_DeleteContext(ctx);
}
TEST(CAPI, TensorHandleSilentCopy) {
  TensorHandleSilentCopy(false, TFE_DEVICE_PLACEMENT_SILENT,
                         TFE_DEVICE_PLACEMENT_SILENT, false);
}
TEST(CAPI, TensorHandleSilentCopyAsync) {
  TensorHandleSilentCopy(true, TFE_DEVICE_PLACEMENT_SILENT,
                         TFE_DEVICE_PLACEMENT_SILENT, false);
}
TEST(CAPI, TensorHandleSilentCopyLocalPolicy) {

  TFE_DeleteContext(ctx);

  // TODO(b/136478427): Figure out how to correctly shut the server down.
  worker_server.release();
}

TEST(CAPI, RemoteExecuteChangeServerDef) {
  TestRemoteExecuteChangeServerDef(false);
}
TEST(CAPI, RemoteExecuteChangeServerDefAsync) {
  TestRemoteExecuteChangeServerDef(true);
}

void TestRemoteExecuteUpdateServerDef(bool async) {

              }
            });
  }

  public void testEquals() {
    ListMultimap<Integer, String> map1 = ImmutableListMultimap.of(1, "one");
    ListMultimap<Integer, String> map2 = ImmutableListMultimap.of(2, "two");
    new EqualsTester()
        .addEqualityGroup(map1, wrap(map1), wrap(map1))
        .addEqualityGroup(map2, wrap(map2))
        .testEquals();
  }