@Override
        public int decode(byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
            return 0;
        }

        @Override
        public int encode(byte[] dst, int dstIndex) {
            return 0;
        }

        @Override
        public void setDigest(SMBSigningDigest digest) {
            this.digest = digest;
        }

    /**
     * Channel statistics.
     */
    public static class ChannelStatistics {
        private final int activeSessions;
        private final int totalChannels;
        private final long totalRequests;
        private final long totalChannelsCreated;

        public ChannelStatistics(int activeSessions, int totalChannels, long totalRequests, long totalChannelsCreated) {
            this.activeSessions = activeSessions;

        assertEquals(int.class, ServerData.class.getDeclaredField("sflags2").getType());
        assertEquals(int.class, ServerData.class.getDeclaredField("smaxMpxCount").getType());
        assertEquals(int.class, ServerData.class.getDeclaredField("maxBufferSize").getType());
        assertEquals(int.class, ServerData.class.getDeclaredField("sessKey").getType());

      int[] quotients = new int[indexes.length];
      int[] remainders = new int[indexes.length];
      // The indexes to select. In the worst case, we'll need one each side of each quantile.
      int[] requiredSelections = new int[indexes.length * 2];
      int requiredSelectionsCount = 0;
      for (int i = 0; i < indexes.length; i++) {

        return set1.contains(element) ^ set2.contains(element);
      }

      @Override
      int minSize() {
        int difference = minSize(set1) - maxSize(set2);
        return difference >= 0 ? difference : max(minSize(set2) - maxSize(set1), 0);
      }

      @Override
      int maxSize() {
        return saturatedAdd(maxSize(set1), maxSize(set2));
      }
    };
  }

  /**

    }
    return result;
  }

  @Benchmark
  int hashFunction(int reps) {
    HashFunction hashFunction = hashFunctionEnum.getHashFunction();
    int result = 37;
    for (int i = 0; i < reps; i++) {
      result ^= hashFunction.hashBytes(testBytes).asBytes()[0];
    }
    return result;
  }

  @Benchmark
  int hashFunctionWithOffset(int reps) {
    HashFunction hashFunction = hashFunctionEnum.getHashFunction();

    for (int i = 0; i < reps; i++) {
      lock.lock();
      lock.unlock();
    }
  }

  @Benchmark
  void orderedPlainLocks(int reps) {
    lockAndUnlockNested(plainLocks, reps);
  }

  @Benchmark
  void orderedCycleDetectingLocks(int reps) {
    lockAndUnlockNested(detectingLocks, reps);
  }

  private static void lockAndUnlockNested(Lock[] locks, int reps) {

     */
    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {

        // When
        int bytesRead = response.readBytesWireFormat(buffer, 0);

        // Then
        assertEquals(4, bytesRead);
    }

    @DisplayName("Should handle structure with different reserved values")
    @ParameterizedTest
    @CsvSource({ "0, 0", "255, 255", "0, 65535", "100, 200" })
    void testReadWithDifferentReservedValues(int byte2, int byte3) throws SMBProtocolDecodingException {

 * #lock(int) strong} and {@linkplain #lazyWeakLock(int) weak} {@code Striped<Lock>}, {@linkplain
 * #semaphore(int, int) strong} and {@linkplain #lazyWeakSemaphore(int, int) weak} {@code
 * Striped<Semaphore>}, and {@linkplain #readWriteLock(int) strong} and {@linkplain
 * #lazyWeakReadWriteLock(int) weak} {@code Striped<ReadWriteLock>}. <i>Strong</i> means that all