}

		// Skip until offset.
		block = block[offset:]

		// Reset the offset for next iteration to read everything
		// from subsequent blocks.
		offset = 0

		// We have written all the blocks, write the last remaining block.
		if write < int64(len(block)) {
			n, err := dst.Write(block[:write])
			if err != nil {
				return 0, err
			}
			totalWritten += int64(n)
			break
		}

		// Copy the block.

      }
    }

    /**
     * Associates {@code key} with {@code value} in the built map. If the same key is put more than
     * once, {@link #buildOrThrow} will fail, while {@link #buildKeepingLast} will keep the last
     * value put for that key.
     */
    @CanIgnoreReturnValue
    public Builder<K, V> put(K key, V value) {
      ensureCapacity(size + 1);
      Entry<K, V> entry = entryOf(key, value);

			nf = dataEnd - sw.pos
			nf, err = io.CopyN(sw.fw, rs, nf)
		}
		sw.pos += nf
		if sw.pos >= dataEnd && len(sw.sp) > 1 {
			sw.sp = sw.sp[1:] // Ensure last fragment always remains
		}
	}

	// If the last fragment is a hole, then seek to 1-byte before EOF, and
	// read a single byte to ensure the file is the right size.
	if readLastByte && err == nil {
		_, err = mustReadFull(rs, []byte{0})

      List<String> list = Lists.newArrayList(elements);
      list.add("zzz");
      return ImmutableSortedSet.copyOf(list).headSet("zzy");
    }
  }

  public static class ImmutableSortedSetTailsetGenerator extends TestStringSortedSetGenerator {
    @Override
    protected SortedSet<String> create(String[] elements) {
      List<String> list = Lists.newArrayList(elements);

            "loc": ["cookie", "santa_tracker"],
            "msg": "Extra inputs are not permitted",
            "input": "good-list-please",
        }
    ]
}
```

## Summary { #summary }

    }
    body.awaitSuccess()
    assertThat(log.take()!!)
      .contains("StreamResetException: stream was reset: CANCEL")
  }

  /**
   * We delay sending the last byte of the request body 1500 ms. The 1000 ms read timeout should
   * only elapse 1000 ms after the request body is sent.
   */
  @Test
  fun headersReadTimeoutDoesNotStartUntilLastRequestBodyByteFire() {

    /**
     * Creates a new SMB1 close file request.
     *
     * @param config the CIFS configuration
     * @param fid the file identifier to close
     * @param lastWriteTime the last write time to set on the file
     */
    public SmbComClose(final Configuration config, final int fid, final long lastWriteTime) {
        super(config, SMB_COM_CLOSE);
        this.fid = fid;

        super.reset();
        this.isPrimary = this.hasMore = true;
    }

    /**
     * Resets the transaction state with key and last name
     * @param key
     *            the key to use for reset
     * @param lastName
     *            the last name for the transaction
     */
    protected void reset(final int key, final String lastName) {
        reset();
    }

    @Override

        // Write notification data at buffer offset 80
        int notifyOffset = 80;
        SMBUtil.writeInt4(0, buffer, notifyOffset); // NextEntryOffset (0 = last entry)
        SMBUtil.writeInt4(1, buffer, notifyOffset + 4); // Action (FILE_ACTION_ADDED)
        // Write filename in Unicode
        String fileName = "test.txt";

document's age at the time it was served based on "Last-Modified". Default expiration dates aren't used for URIs 
containing a query.

 - CallStart
 - **CacheHit**
 - CallEnd
 
### Cache Miss

Under a cache miss the normal request events are seen but an additional event shows the presence of the cache.
Cache Miss will be typical if the item has not been read from the network, is uncacheable, or is past it's 
lifetime based on Response cache headers.