// Test that getQueryClassName returns the correct class name
        assertEquals("BoostQuery", boostQueryCommand.getQueryClassName());
    }

    public void test_execute_withTermQuery() {
        // Test executing BoostQuery with a TermQuery inside
        Term term = new Term("field", "value");
        TermQuery termQuery = new TermQuery(term);
        BoostQuery boostQuery = new BoostQuery(termQuery, 2.5f);

        }
        throw e;
        // The execution of a task has ended abnormally.
        // We could have tasks left in the queue, so should perhaps try to restart a worker,
        // but then the Error will get delayed if we are using a direct (same thread) executor.
      }
    }

    /**
     * Continues executing tasks from {@link #queue} until it is empty.
     *

          log.log(
              Level.SEVERE,
              "RuntimeException while executing runnable "
                  + runnable
                  + " with executor "
                  + executor,
              e);
        }
      }
    }
  }

  // A version of the execution list that doesn't reverse the stack in execute().
  private static final class NewExecutionListWithoutReverse {

    Class<?> ensureLoaded = LockSupport.class;
  }

  private static final class DoNothingRunnable implements Runnable {
    @Override
    public void run() {}
  }

  // The thread executing the task publishes itself to the superclass' reference and the thread
  // interrupting sets DONE when it has finished interrupting.
  private static final Runnable DONE = new DoNothingRunnable();

         *
         * @return true if the thread is actively executing
         */
        public boolean isRunning() {
            return running;
        }

        /**
         * Waits for the crawling thread to terminate.
         * This method blocks until the thread completes its execution.
         * Interrupted exceptions are caught and logged at debug level.
         */

    /**
     * Determines whether plugins should be processed during project building.
     * When true, the builder will process plugin information which may include
     * resolving plugin dependencies and executing plugin goals that participate in project building.
     *
     * @return true if plugins should be processed, false otherwise
     */
    boolean isProcessPlugins();

    /**

          // can't know without submitting something to the executor) so queue to run iteratively.
          // Task must be null, since each execution on this executor can only produce one more
          // execution.
          checkState(submittingTaskQueue.nextTask == null);
          submittingTaskQueue.nextTask = task;

    protected String compression = null;

    /**
     * The SSL socket factory for secure connections.
     */
    protected SSLSocketFactory sslSocketFactory = null;

    /**
     * The thread pool for executing the request.
     */
    protected ForkJoinPool threadPool;

    /**
     * The connection builder for customizing the connection.
     */

      return (data.get((int) (bitIndex >>> LONG_ADDRESSABLE_BITS)) & (1L << bitIndex)) != 0;
    }

    /**
     * Careful here: if threads are mutating the atomicLongArray while this method is executing, the
     * final long[] will be a "rolling snapshot" of the state of the bit array. This is usually good
     * enough, but should be kept in mind.
     */

// The panic built-in function stops normal execution of the current
// goroutine. When a function F calls panic, normal execution of F stops
// immediately. Any functions whose execution was deferred by F are run in
// the usual way, and then F returns to its caller. To the caller G, the
// invocation of F then behaves like a call to panic, terminating G's
// execution and running any deferred functions. This continues until all