private volatile Thread thread;
    private volatile TransportException te;

    /**
     * Lock object for synchronizing input operations
     */
    protected final Object inLock = new Object();
    /**
     * Lock object for synchronizing output operations
     */
    protected final Object outLock = new Object();

    /**
     * Map for tracking pending responses by their key
     */

     * @return A map of query parameters.
     */
    public Map<String, Object> params() {
        return params;
    }

    /**
     * Sets the parameters for the LTR query.
     *
     * @param params A map of query parameters.
     * @return This query builder.
     */
    public StoredLtrQueryBuilder params(final Map<String, Object> params) {
        this.params = Objects.requireNonNull(params);

        int bytesRead = response.readDataWireFormat(buffer, 0, buffer.length);

        assertEquals(20, bytesRead, "Should read 20 bytes");
        assertNotNull(response.info, "Info object should not be null");
        assertTrue(response.info instanceof Trans2QueryFSInformationResponse.SmbInfoAllocation, "Info should be of type SmbInfoAllocation");

                for (final SearchHit hit : hits) {
                    final Map<String, Object> source = hit.getSourceAsMap();
                    if (limitOfDocumentSize > 0) {
                        long size = 0;
                        for (final String field : supportedFields) {
                            final Object value = source.get(field);
                            if (value != null) {

	},
	ErrObjectLockInvalidHeaders: {
		Code:           "InvalidRequest",
		Description:    "x-amz-object-lock-retain-until-date and x-amz-object-lock-mode must both be supplied",
		HTTPStatusCode: http.StatusBadRequest,
	},
	ErrObjectRestoreAlreadyInProgress: {
		Code:           "RestoreAlreadyInProgress",
		Description:    "Object restore is already in progress",
		HTTPStatusCode: http.StatusConflict,
	},

    Object one = new Object();
    Object two = new Object();
    CacheLoader<Object, Object> loader =
        new CacheLoader<Object, Object>() {
          @Override
          public Object load(Object key) {
            return one;
          }

          @Override
          public ListenableFuture<Object> reload(Object key, Object oldValue) {
            return immediateFuture(two);

  }

  public void testGetUnchecked_unchecked() {
    RuntimeException cause = new RuntimeException();
    AtomicReference<Object> valueRef = new AtomicReference<>();
    LoadingCache<Object, Object> cache =
        new AbstractLoadingCache<Object, Object>() {
          @Override
          public Object get(Object key) throws ExecutionException {
            Object v = valueRef.get();
            if (v == null) {

        String template = "${level1.level2.value}";
        Map<String, Object> paramMap = new HashMap<>();
        Map<String, Object> level2 = new HashMap<>();
        level2.put("value", "nested");
        Map<String, Object> level1 = new HashMap<>();
        level1.put("level2", level2);
        paramMap.put("level1", level1);

        Object result = scriptEngine.evaluate(template, paramMap);
        assertEquals("nested", result);
    }

    CacheLoader<Object, Object> baseLoader =
        new CacheLoader<Object, Object>() {
          @Override
          public Object load(Object key) {
            loadCount.incrementAndGet();
            return new Object();
          }

          @Override
          public ListenableFuture<Object> reload(Object key, Object oldValue) {
            reloadCount.incrementAndGet();

      source, and configuration files.

      "Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

      "Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a