}

TF_CAPI_EXPORT extern int TFE_OpGetInputLength(TFE_Op* op,
                                               const char* input_name,
                                               TF_Status* status) {
  int ret = -1;
  status->status = tensorflow::unwrap(op)->InputLength(input_name, &ret);
  return ret;
}

TF_CAPI_EXPORT extern int TFE_OpGetOutputLength(TFE_Op* op,

    val bit = 1 shl MAX_CONCURRENT_STREAMS
    return if (bit and set != 0) values[MAX_CONCURRENT_STREAMS] else Int.MAX_VALUE
  }

  fun getMaxFrameSize(defaultValue: Int): Int {
    val bit = 1 shl MAX_FRAME_SIZE
    return if (bit and set != 0) values[MAX_FRAME_SIZE] else defaultValue
  }

  fun getMaxHeaderListSize(defaultValue: Int): Int {
    val bit = 1 shl MAX_HEADER_LIST_SIZE

        return new Smb2LeaseBreakResponse(tc.getConfig());
    }

    @Override
    public int size() {
        return size8(Smb2Constants.SMB2_HEADER_LENGTH + STRUCTURE_SIZE);
    }

    @Override
    protected int writeBytesWireFormat(byte[] dst, int dstIndex) {
        int start = dstIndex;

        // StructureSize (2 bytes) - must be 36
        SMBUtil.writeInt2(STRUCTURE_SIZE, dst, dstIndex);

        Funnel<? super T> funnel,
        int numHashFunctions,
        LockFreeBitArray bits) {
      long bitSize = bits.bitSize();
      long hash64 = murmur3_128().hashObject(object, funnel).asLong();
      int hash1 = (int) hash64;
      int hash2 = (int) (hash64 >>> 32);

      boolean bitsChanged = false;
      for (int i = 1; i <= numHashFunctions; i++) {
        int combinedHash = hash1 + (i * hash2);

            int[] disconnectedStates = { 0, 4, 5, 6 };
            int[] connectedStates = { 1, 2, 3 };

            for (int state : disconnectedStates) {
                transport.setState(state);
                assertTrue(transport.isDisconnected(), "State " + state + " should be disconnected");
            }

            for (int state : connectedStates) {

        return this.endOfFile;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.allocationSize = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;

 * #hashBytes(byte[], int, int)} method.
 *
 * @author Dimitris Andreou
 */
@Immutable
abstract class AbstractNonStreamingHashFunction extends AbstractHashFunction {
  @Override
  public Hasher newHasher() {
    return newHasher(32);
  }

  @Override
  public Hasher newHasher(int expectedInputSize) {
    Preconditions.checkArgument(expectedInputSize >= 0);

     */
    public static final int SMB_DIRECT_RESPONSE_REQUESTED = 0x00000001;

    /**
     * Default maximum size for RDMA read/write operations (1MB)
     */
    public static final int DEFAULT_RDMA_READ_WRITE_SIZE = 1048576; // 1MB

    /**
     * Default maximum number of receive credits
     */
    public static final int DEFAULT_RECEIVE_CREDIT_MAX = 255;

    /**

   * hereby disclaims copyright to this source code.
   */
  static int smear(int hashCode) {
    return (int) (C2 * Integer.rotateLeft((int) (hashCode * C1), 15));
  }

  static int smearedHash(@Nullable Object o) {
    return smear((o == null) ? 0 : o.hashCode());
  }

  private static final int MAX_TABLE_SIZE = Ints.MAX_POWER_OF_TWO;

  static int closedTableSize(int expectedEntries, double loadFactor) {

    @DisplayName("Should calculate correct size")
    void testSize() {
        // When
        int size = request.size();

        // Then
        // Size should be aligned to 8 bytes: SMB2_HEADER_LENGTH + 32
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 32;
        // The size8 method aligns to 8-byte boundary
        int alignedSize = (expectedSize + 7) & ~7;
        assertEquals(alignedSize, size);
    }