}

    /**
     * Get the address the service is listening on
     *
     * @return the service address
     * @throws IOException if address cannot be determined
     */
    public InetAddress getAddress() throws IOException {
        if (serverSocket == null) {
            throw new IOException("Service not started");
        }
        return InetAddress.getLocalHost();
    }

    /**

        // Test execute method with negative boost - should throw exception
        QueryContext context = new QueryContext("*:*", false);
        MatchAllDocsQuery query = new MatchAllDocsQuery();
        float boost = -1.0f;

        try {
            matchAllQueryCommand.execute(context, query, boost);
            fail("Should throw IllegalArgumentException for negative boost");

        // Callback should still be invoked even if it throws
        assertTrue("Callback should be invoked", latch.await(10, TimeUnit.SECONDS));
        assertEquals("Callback should be called", 1, callbackCount.get());
    }

    @Test
    public void test_errorCallbackException_doesNotBreakDeferred() throws Exception {
        final Deferred<SuggestResponse> deferred = new Deferred<>();

     * @throws IOException IOException if any.
     * @throws XmlPullParserException XmlPullParserException if
     * any.
     * @return Model
     */
    public Model read(Reader reader) throws IOException, XmlPullParserException {
        return read(reader, true);
    } // -- Model read( Reader )

    protected Model read(InputStream is, boolean strict, InputSource source)

    try {
      return q.toString();
    } finally {
      monitor.leave();
    }
  }

  /**
   * @throws UnsupportedOperationException {@inheritDoc}
   * @throws ClassCastException {@inheritDoc}
   * @throws NullPointerException {@inheritDoc}
   * @throws IllegalArgumentException {@inheritDoc}
   */
  @CanIgnoreReturnValue // pushed down from class to method
  @Override

      throws InterruptedException {
    Preconditions.checkNotNull(tasks, "tasks must not be null!");
    return delegate.invokeAll(tasks);
  }

  @Override
  public <T> List<Future<T>> invokeAll(
      Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
      throws InterruptedException {

      throws InterruptedException {
    Preconditions.checkNotNull(tasks, "tasks must not be null!");
    return delegate.invokeAll(tasks);
  }

  @Override
  public <T> List<Future<T>> invokeAll(
      Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)
      throws InterruptedException {

        @ParametricNullness V value) {
      throw new UnsupportedOperationException();
    }

    @Override
    public void putAll(Table<? extends R, ? extends C, ? extends V> table) {
      throw new UnsupportedOperationException();
    }

    @Override
    public @Nullable V remove(@Nullable Object rowKey, @Nullable Object columnKey) {
      throw new UnsupportedOperationException();
    }

    private SuggestCreator suggestCreator;

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        suggestCreator = new SuggestCreator();
    }

    @Override
    protected void tearDown(TestInfo testInfo) throws Exception {
        super.tearDown(testInfo);
    }

    // Test constructor
    @Test
    public void test_constructor() {

     * @throws IOException if an I/O error occurs
     */
    public short readShort() throws IOException {
        align(2);
        return Short.reverseBytes(this.dis.readShort());
    }

    /**
     * Reads a 32-bit integer value with proper alignment and byte order.
     * @return the integer value in little-endian format
     * @throws IOException if an I/O error occurs
     */
    public int readInt() throws IOException {