// methods with primitive types will work correctly.
            if (parameterType.isPrimitive()) {
                if (parameterType.equals(Boolean.TYPE)) {
                    methodKey.append("java.lang.Boolean");
                } else if (parameterType.equals(Byte.TYPE)) {
                    methodKey.append("java.lang.Byte");
                } else if (parameterType.equals(Character.TYPE)) {

    String s1 = "foo";
    String s2 = MoreObjects.firstNonNull(s1, "bar");
    assertSame(s1, s2);

    Long n1 = 42L;
    Long n2 = MoreObjects.firstNonNull(null, n1);
    assertSame(n1, n2);

    Boolean b1 = true;
    Boolean b2 = MoreObjects.firstNonNull(b1, null);
    assertSame(b1, b2);
  }

  public void testFirstNonNull_throwsNullPointerException() {

    String s1 = "foo";
    String s2 = MoreObjects.firstNonNull(s1, "bar");
    assertSame(s1, s2);

    Long n1 = 42L;
    Long n2 = MoreObjects.firstNonNull(null, n1);
    assertSame(n1, n2);

    Boolean b1 = true;
    Boolean b2 = MoreObjects.firstNonNull(b1, null);
    assertSame(b1, b2);
  }

  public void testFirstNonNull_throwsNullPointerException() {

  val isOptional: Boolean = false,
  /** The value to return if this value is absent. Undefined unless this is optional. */
  val defaultValue: T? = null,
  /** True to set the encoded or decoded value as the type hint for the current SEQUENCE. */
  private val typeHint: Boolean = false,
) : DerAdapter<T> {
  init {
    require(tagClass >= 0)
    require(tag >= 0)
  }

    if (planningThrowable != null) throw planningThrowable

    return result
  }

  override fun hasNext(failedConnection: RealConnection?): Boolean =
    deferredPlans.isNotEmpty() || nextPlanIndex < plans.size || autoGeneratePlans

  override fun sameHostAndPort(url: HttpUrl): Boolean = url.host == address.url.host && url.port == address.url.port

  override fun close() {
    factory.close()
  }

  inner class FakePlan(

  static {
    Map<Class<?>, Class<?>> primToWrap = new LinkedHashMap<>(16);
    Map<Class<?>, Class<?>> wrapToPrim = new LinkedHashMap<>(16);

    add(primToWrap, wrapToPrim, boolean.class, Boolean.class);
    add(primToWrap, wrapToPrim, byte.class, Byte.class);
    add(primToWrap, wrapToPrim, char.class, Character.class);
    add(primToWrap, wrapToPrim, double.class, Double.class);

    //                                                                         ===========
    @Override
    public boolean hasPrimaryKey() {
        return false;
    }

    @Override
    public boolean hasCompoundPrimaryKey() {
        return false;
    }

    @Override
    protected UniqueInfo cpui() {
        return null;
    }

    private Maven4ScopeManagerConfiguration() {}

    @Override
    public String getId() {
        return "Maven4";
    }

    @Override
    public boolean isStrictDependencyScopes() {
        return false;
    }

    @Override
    public boolean isStrictResolutionScopes() {
        return false;
    }

    @Override
    public BuildScopeSource getBuildScopeSource() {

     */
    public boolean needsKeyRotation() {
        return needsKeyRotation(0);
    }

    /**
     * Check if key rotation is needed, considering additional bytes to be encrypted
     *
     * @param additionalBytes bytes about to be encrypted
     * @return true if key rotation is needed
     */
    public boolean needsKeyRotation(int additionalBytes) {

        private final boolean matchResult;
        private int matchCallCount = 0;

        public TestRule(String ruleId, ResponseProcessor responseProcessor, boolean matchResult) {
            this.ruleId = ruleId;
            this.responseProcessor = responseProcessor;
            this.matchResult = matchResult;
        }

        @Override
        public boolean match(ResponseData responseData) {