assertSame(canonical, pool.intern(not));
  }

  public void testStrong_null() {
    Interner<String> pool = Interners.newStrongInterner();
    assertThrows(NullPointerException.class, () -> pool.intern(null));
  }

  public void testStrong_builder() {
    int concurrencyLevel = 42;
    Interner<Object> interner =
        Interners.newBuilder().strong().concurrencyLevel(concurrencyLevel).build();

    if (result == null) {
      result = Ordering.from(forwardMultiset().comparator()).reverse();
      comparator = result;
    }
    return result;
  }

  @LazyInit private transient @Nullable NavigableSet<E> elementSet;

  @Override
  public NavigableSet<E> elementSet() {
    NavigableSet<E> result = elementSet;
    if (result == null) {

        validate(form, messages -> {}, validationErrorLambda);

        if (!form.newPassword.equals(form.confirmNewPassword)) {
            form.newPassword = null;
            form.confirmNewPassword = null;
            throwValidationError(messages -> {
                messages.addErrorsInvalidConfirmPassword(GLOBAL);
            }, validationErrorLambda);
        }

    public String[] getLabelTypeIds() {
        if (labelTypeIds == null) {
            return StringUtil.EMPTY_STRINGS;
        }
        return labelTypeIds;
    }

    public void setLabelTypeIds(final String[] labelTypeIds) {
        this.labelTypeIds = labelTypeIds;
    }

    public List<LabelType> getLabelTypeList() {
        if (labelTypeList == null) {
            synchronized (this) {

        builder.startObject();
        if (sessionId != null) {
            builder.field(SESSION_ID, sessionId);
        }
        if (filterType != null) {
            builder.field(FILTER_TYPE, filterType);
        }
        if (url != null) {
            builder.field(URL, url);
        }
        builder.endObject();
        return builder;
    }

    content: String? = null,
    fn: (FileDescriptor) -> T,
  ): T =
    assertOnPath(content) {
      FileInputStream(filePath.toFile()).use { fis ->
        fn(fis.fd)
      }
    }

  private inline fun <T> assertOnPath(
    content: String? = null,
    fn: (okio.Path) -> T,
  ): T {
    FileSystem.SYSTEM.write(filePath) {
      if (content != null) {
        writeUtf8(content)
      }

     *
     * @param message The error message, may be {@code null}.
     * @param lineNumber The one-based index of the line containing the error or {@code -1} if unknown.
     * @param columnNumber The one-based index of the column containing the error or {@code -1} if unknown.
     * @param cause The nested cause of this error, may be {@code null}.
     */

    initMultimapWithNullKey();

    assertContentsAnyOrder(multimap().removeAll(null), getValueForNullKey());

    expectMissing(mapEntry((K) null, getValueForNullKey()));
  }

  @MapFeature.Require({SUPPORTS_REMOVE, ALLOWS_ANY_NULL_QUERIES})
  public void testRemoveAllNullKeyAbsent() {
    assertEmpty(multimap().removeAll(null));
    expectUnchanged();
  }

                            "anyOf": [{"type": "string"}, {"type": "null"}],
                        },
                        "price": {"title": "Price", "type": "number"},
                        "tax": {
                            "title": "Tax",
                            "anyOf": [{"type": "number"}, {"type": "null"}],
                        },
                    },
                },

  public void testImmutableEntryNull() {
    Entry<@Nullable String, @Nullable Integer> e = immutableEntry((String) null, (Integer) null);
    assertThat(e.getKey()).isNull();
    assertThat(e.getValue()).isNull();
    assertThrows(UnsupportedOperationException.class, () -> e.setValue(null));
    assertEquals("null=null", e.toString());
    assertEquals(0, e.hashCode());
  }