return BoostQuery.class.getSimpleName();
    }

    @Override
    public QueryBuilder execute(final QueryContext context, final Query query, final float boost) {
        if (query instanceof final BoostQuery boostQuery) {
            if (logger.isDebugEnabled()) {
                logger.debug("{}:{}", query, boost);
            }

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

  @Override
  public boolean equals(@Nullable Object object) {
    if (object instanceof Entry) {
      Entry<?, ?> that = (Entry<?, ?>) object;
      return Objects.equals(this.getKey(), that.getKey())
          && Objects.equals(this.getValue(), that.getValue());
    }
    return false;
  }

  /**
   * Returns a representation of {@code a} as an instance of type {@code B}. If {@code a} cannot be
   * converted, an unchecked exception (such as {@link IllegalArgumentException}) should be thrown.
   *
   * @param a the instance to convert; will never be null
   * @return the converted instance; <b>must not</b> be null
   */
  @ForOverride
  protected abstract B doForward(A a);

        return 0L;
    }

    @Override
    public long length() {
        return 0L;
    }

    @Override
    public boolean equals(final Object obj) {
        if (obj instanceof final SmbShareInfo si) {
            return Objects.equals(this.netName, si.netName);
        }
        return false;
    }

    @Override
    public int hashCode() {

            ASN1TaggedObject mechToken = ASN1Util.as(ASN1TaggedObject.class, stream.readObject());
            if (mechToken == null || mechToken.getTagClass() != BERTags.APPLICATION
                    || !(mechToken.getBaseObject() instanceof ASN1Sequence)) {
                throw new PACDecodingException("Malformed kerberos token");
            }

            this.apRequest = new KerberosApRequest((ASN1Sequence) mechToken.getBaseObject(), keys);

    }

    @Override
    protected String doBackward(T enumValue) {
      return enumValue.name();
    }

    @Override
    public boolean equals(@Nullable Object obj) {
      if (obj instanceof StringConverter) {
        StringConverter<?> that = (StringConverter<?>) obj;
        return this.enumClass.equals(that.enumClass);
      }
      return false;
    }

    @Override

     * values} if it is a Set and therefore probably already deduplicated.
     */
    int expectedValueCollectionSize(int defaultExpectedValues, Iterable<?> values) {
      if (values instanceof Collection<?>) {
        Collection<?> collection = (Collection<?>) values;
        return max(defaultExpectedValues, collection.size());
      } else {
        return defaultExpectedValues;
      }
    }

        Map<String, Object> retrievedDoc = result.getDocumentList().get(0);
        assertEquals("complex", retrievedDoc.get("id"));
        assertTrue(retrievedDoc.get("nested") instanceof Map);
        assertTrue(retrievedDoc.get("list") instanceof List);
    }

            return (T) method.invoke(target, args);
        } catch (final InvocationTargetException ex) {
            final Throwable t = ex.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            }
            if (t instanceof Error) {
                throw (Error) t;
            }
            throw new InvocationTargetRuntimeException(method.getDeclaringClass(), ex);

        // Verify parent class initialization
        assertNotNull(msrpcShareGetInfo.info);
        assertTrue(msrpcShareGetInfo.info instanceof srvsvc.ShareInfo502);
        assertEquals(502, msrpcShareGetInfo.level);
        assertEquals(testServer, msrpcShareGetInfo.servername);
        assertEquals(testSharename, msrpcShareGetInfo.sharename);
    }