if (matchesName(declaration.fieldName, field.name) && declaration.isSince(version)) true
            else null

        override fun visit(declaration: EnumConstantDeclaration, arg: Unit?): Boolean? =
            if (declaration.matchesNameAndIsSince(field.name, version)) true
            else null
    }


private
fun isSinceJavaConstructorVisitorFor(classSimpleName: String, version: String) =

        assertThat(StringUtil.defaultString("aaa", null), is("aaa"));
        assertThat(StringUtil.defaultString(null, null), is(nullValue()));
    }

    @Test
    public void testNewStringUnsafe() {
        assertNull(StringUtil.newStringUnsafe(null));
        Method newStringUnsafeMethod = StringUtil.newStringUnsafeMethod;
        if (newStringUnsafeMethod != null) {

      return get(key) != null;
    }

    @Override
    public void clear() {
      FilteredEntryMultimap.this.clear();
    }

    @Override
    @CheckForNull
    public Collection<V> get(@CheckForNull Object key) {
      Collection<V> result = unfiltered.asMap().get(key);
      if (result == null) {
        return null;
      }

   */
  protected Entry<K, V>[] createArrayWithNullValue() {
    Entry<K, V>[] array = createSamplesArray();
    int nullValueLocation = getNullLocation();
    Entry<K, V> oldEntry = array[nullValueLocation];
    array[nullValueLocation] = mapEntry(oldEntry.getKey(), null);
    return array;
  }

  /**

        try {
            final SuggestItem item =
                    contentsParser.parseSearchWords(words, null, fields, tags, roles, num, readingConverter, normalizer, analyzer, langs);
            if (item == null) {
                return new SuggestIndexResponse(0, 1, null, System.currentTimeMillis() - start);
            }
            final long parseTime = System.currentTimeMillis();

                            "required": False,
                            "schema": IsDict(
                                {
                                    "anyOf": [{"type": "string"}, {"type": "null"}],
                                    "title": "Q",
                                }
                            )
                            | IsDict(

   * `heldCertificate` is null.
   */
  @JvmStatic
  fun newKeyManager(
    keyStoreType: String?,
    heldCertificate: HeldCertificate?,
    vararg intermediates: X509Certificate,
  ): X509KeyManager {
    val keyStore = newEmptyKeyStore(keyStoreType)
    if (heldCertificate != null) {
      val chain = arrayOfNulls<Certificate>(1 + intermediates.size)

 *     Object}, or use {@code @Nullable Object} to allow null values.
 * @since 2.0
 */
@DoNotMock("Use ImmutableClassToInstanceMap or MutableClassToInstanceMap")
@GwtCompatible
@ElementTypesAreNonnullByDefault
public interface ClassToInstanceMap<B extends @Nullable Object>
    extends Map<Class<? extends @NonNull B>, B> {
  /**
   * Returns the value the specified class is mapped to, or {@code null} if no entry for this class

            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        }).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        });
        protwordsService.store(body.dictId, entity);
        return asJson(

    expectUnchanged();
    assertTrue(collection.contains(e0()));
  }

  /*
   * AbstractCollection fails the removeAll(null) test when the subject
   * collection is empty, but we'd still like to test removeAll(null) when we
   * can. We split the test into empty and non-empty cases. This allows us to
   * suppress only the former.
   */

  @CollectionFeature.Require(SUPPORTS_REMOVE)