return filterChain.execute(context, query, boost);
    }

    public void add(final String name, final QueryCommand queryCommand) {
        if (name == null || queryCommand == null) {
            throw new IllegalArgumentException("name or queryCommand is null.");
        }
        if (logger.isDebugEnabled()) {
            logger.debug("Loaded {}", name);
        }
        queryCommandMap.put(name, queryCommand);
    }

  }

  @CollectionFeature.Require(absent = ALLOWS_NULL_VALUES)
  public void testFind_nullNotContainedAndUnsupported() {
    try {
      assertEquals(getMethodName() + "(nullNotPresent) should return -1 or throw", -1, find(null));
    } catch (NullPointerException tolerated) {
    }
  }

  @CollectionFeature.Require(ALLOWS_NULL_VALUES)
  @CollectionSize.Require(absent = ZERO)
  public void testFind_nonNullWhenNullContained() {

            final T o = items[index];
            index++;
            return o;
        } catch (final IndexOutOfBoundsException e) {
            throw new NoSuchElementException("index=" + index);
        }
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

    }

    @Override
    public ClassLoader next() {
        if (!hasNext()) {
            throw new NoSuchElementException();
        }
        final ClassLoader result = classLoader;
        classLoader = classLoader.getParent();
        return result;
    }

    @Override
    public void remove() {
        throw new ClUnsupportedOperationException("remove");
    }

            // 404
            throw responseManager.new404("Thumbnail for " + form.docId + " is not found.");
        }

        final File thumbnailFile = thumbnailManager.getThumbnailFile(doc);
        if (thumbnailFile == null) {
            if (fessConfig.isThumbnailEnabled()) {
                thumbnailManager.offer(doc);
            }
            // 404

            }
        }
        throw new IOException();
    }


    /**
     * @param msg
     * @param in
     * @param off
     * @param isDirect
     * @return
     * @throws IOException
     * @throws DcerpcException
     * @throws NdrException
     */
    private byte[] receiveMoreFragments ( DcerpcMessage msg, byte[] in ) throws IOException, DcerpcException, NdrException {

            providedArtifacts = coreExports.getExportedArtifacts();
        } else if (STRATEGY_SELF_FIRST.equals(classLoadingStrategy)) {
            realm.setParentRealm(parentRealm);
        } else {
            throw new IllegalArgumentException("Unsupported class-loading strategy '"
                    + classLoadingStrategy + "'. Supported values are: " + STRATEGY_PARENT_FIRST

    }


    @Test
    public void test () throws IOException {
        runReadWriteTest(4096, 4 * 4096);
    }


    @Test
    public void testExactWrite () throws IOException {
        runReadWriteTest(4096, 4096);
    }


    @Test
    public void testSmallWrite () throws IOException {
        runReadWriteTest(4096, 1013);
    }


    @Test

            throws ArtifactResolutionException, ArtifactNotFoundException {
        if (Artifact.LATEST_VERSION.equals(artifact.getVersion())) {
            try {
                String version = resolveVersion(artifact, request);
                if (Artifact.LATEST_VERSION.equals(version)) {
                    throw new ArtifactNotFoundException("Unable to determine the latest version", artifact);

    } catch (ExecutionException e) {
      throw e.getCause();
    }
  }

  /**
   * Verify that the listener completes in a reasonable amount of time, and Asserts that the future
   * throws an {@code ExecutableException} and that the cause of the {@code ExecutableException} is
   * {@code expectedCause}.
   */
  public void assertException(Throwable expectedCause) throws Exception {