checkNonnegative(distance, "distance");
      long result = origin + distance;
      if (result < 0) {
        checkArgument(origin < 0, "overflow");
      }
      return result;
    }

    @Override
    public long distance(Long start, Long end) {
      long result = end - start;
      if (end > start && result < 0) { // overflow
        return Long.MAX_VALUE;
      }

   */
  @CanIgnoreReturnValue
  public double addAndGet(int i, double delta) {
    return accumulateAndGet(i, delta, Double::sum);
  }

  /**
   * Atomically updates the element at index {@code i} with the results of applying the given
   * function to the current and given values.
   *
   * @param i the index to update
   * @param x the update value
   * @param accumulatorFunction the accumulator function

        System.arraycopy(testData, 0, buffer, bufferIndex + 16, testData.length);

        // Decode
        int bytesDecoded = response.decode(buffer, bufferIndex, buffer.length);

        // Verify results
        assertEquals(namedPipeState, response.getNamedPipeState());
        assertEquals(readDataAvailable, response.getReadDataAvailable());
        assertEquals(numberOfMessages, response.getNumberOfMessages());

    @CustomSize(maxKey = "form.admin.max.input.size")
    public String excludedPaths;

    /** The document paths to include in search results (pattern-based). */
    @CustomSize(maxKey = "form.admin.max.input.size")
    public String includedDocPaths;

    /** The document paths to exclude from search results (pattern-based). */
    @CustomSize(maxKey = "form.admin.max.input.size")
    public String excludedDocPaths;

 * [receiveRequest] in the sequence they are run.
 */
class MockSocketHandler : SocketHandler {
  private val actions = LinkedBlockingQueue<Action>()
  private val results = LinkedBlockingQueue<FutureTask<Void>>()

  fun receiveRequest(expected: String) =
    apply {
      actions += { stream ->
        val actual = stream.source.readUtf8(expected.utf8Size())

            // Send the RPC request
            rpcHandle.sendrecv(message);

            // Create response from RPC message results
            WitnessRegisterResponse response = new WitnessRegisterResponse();
            response.setReturnCode(message.getReturnCode());

            if (message.isSuccess()) {

    /**
     * Protocol overhead size for SMB2 query directory response
     */
    public static final int OVERHEAD = Smb2Constants.SMB2_HEADER_LENGTH + 8;

    private final byte expectInfoClass;
    private FileEntry[] results;

    /**
     * Constructs a SMB2 query directory response with the specified configuration and expected information class
     *
     * @param config
     *            the configuration to use for this response

      checkNonnegative(distance, "distance");
      long result = origin + distance;
      if (result < 0) {
        checkArgument(origin < 0, "overflow");
      }
      return result;
    }

    @Override
    public long distance(Long start, Long end) {
      long result = end - start;
      if (end > start && result < 0) { // overflow
        return Long.MAX_VALUE;
      }

                        if (file.exists()) {
                            results.add(file);
                        }
                    } catch (IOException e) {
                        log.debug("Error checking existence of: " + path, e);
                    }
                }
            }
        }
        
        return results;
    }
}
```

### 7.2 Hierarchical Cache Management
```java

    int readDataWireFormat(final byte[] buffer, int bufferIndex, final int len) {
        final int start = bufferIndex;
        ServerInfo1 e = null;

        results = new ServerInfo1[numEntries];
        for (int i = 0; i < numEntries; i++) {
            results[i] = e = new ServerInfo1();
            e.name = readString(buffer, bufferIndex, 16, false);
            bufferIndex += 16;