if (structureSize != 24) {
            throw new SMBProtocolDecodingException("Expected structureSize = 24");
        }

        this.oplockLevel = buffer[bufferIndex + 2];
        bufferIndex += 4;
        bufferIndex += 4; // Reserved2

        this.fileId = new byte[16];
        System.arraycopy(buffer, bufferIndex, this.fileId, 0, 16);
        bufferIndex += 16;

    /**
     * Create new RDMA channel info
     *
     * @param remoteKey remote memory key for RDMA access (token)
     * @param address remote memory address (offset)
     * @param length length of the memory region
     */
    public RdmaChannelInfo(int remoteKey, long address, int length) {
        // Create SMB2_RDMA_TRANSFORM structure
        this.transform = new Smb2RdmaTransform(address, remoteKey, length);
    }

        assertArgumentNotNull("resultSet", resultSet);

        try {
            return resultSet.next();
        } catch (final SQLException ex) {
            throw new SQLRuntimeException(ex);
        }
    }

    /**
     * Moves the cursor to the specified position.
     *
     * @param resultSet
     *            The result set. Must not be {@literal null}.

public class InvokerException extends MavenException {
    /**
     * Constructs a new {@code InvokerException} with the specified detail message.
     *
     * @param message the detail message explaining the cause of the exception
     */
    public InvokerException(@Nullable String message) {
        super(message);
    }

    /**
     * Constructs a new {@code InvokerException} with the specified detail message and cause.
     *

        final String msg = request.getHeader("Authorization");
        if (msg != null && (msg.startsWith("NTLM ") || offerBasic && msg.startsWith("Basic "))) {
            if (loadBalance) {
                dc = new UniAddress(NbtAddress.getByName(domainController, 0x1C, null));
            } else {
                dc = UniAddress.getByName(domainController, true);
            }
            NtlmPasswordAuthentication ntlm;

        /**
         * Returns the algorithm end result as string, never {@code null}. After invoking this method, this instance should
         * be discarded and not reused. For new checksum calculation you have to get new instance.
         */
        @Nonnull
        String checksum();
    }

    class InvalidPath {
        @Test
        void acceptWithNullThrows() {
            SmbFileFilter throwOnNull = new SmbFileFilter() {
                @Override
                public boolean accept(SmbFile file) throws SmbException {
                    if (file == null) {
                        throw new SmbException("null file");
                    }
                    return true;
                }
            };

        final List<String> sessionIdList = new ArrayList<>();
        dataCrawlingThreadList.clear();
        final List<String> dataCrawlingThreadStatusList = new ArrayList<>();
        for (final DataConfig dataConfig : configList) {
            final DataStoreParams initParamMap = new DataStoreParams();

            holder = null;
          }
        }
        return false;
      }

      @Override
      Splitr createSplit(Spliterator<T> from, long i) {
        return new Splitr(from, i);
      }
    }
    return StreamSupport.stream(new Splitr(fromSpliterator, 0), isParallel).onClose(stream::close);
  }

  /**
   * Returns a stream consisting of the results of applying the given function to the elements of

      Bound to) {
    TestSortedSetGenerator<E> delegate =
        (TestSortedSetGenerator<E>) parentBuilder.getSubjectGenerator().getInnerGenerator();

    List<Feature<?>> features = new ArrayList<>(parentBuilder.getFeatures());
    Set<Method> suppressing = new HashSet<>(parentBuilder.getSuppressedTests());
    features.add(CollectionFeature.SUBSET_VIEW);
    if (features.remove(CollectionFeature.ALLOWS_NULL_VALUES)) {