* <p>The {@code @Nullable} annotations on the {@code equalityGroup} parameter imply that the
   * objects, and the array itself, can be null. That is for programmer convenience, when the
   * objects come from factory methods that are themselves {@code @Nullable}. In reality neither the
   * array nor its contents can be null, but it is not useful to force the use of {@code
   * requireNonNull} or the like just to assert that.
   *

    protected void finalize() throws Throwable {
        try {
            // Add null check to prevent NPE if object was not fully constructed
            if (this.usageCount != null && this.usageCount.get() != 0) {
                log.warn("Tree handle was not properly released, performing emergency cleanup: "
                        + (this.resourceLoc != null ? this.resourceLoc.getURL() : "unknown"));
                emergencyReleaseHandle();

     */
    public String getModelId() {
        if (result == null) {
            return "";
        } else if (result.getEffectiveModel() != null) {
            return result.getEffectiveModel().getId();
        } else if (result.getRawModel() != null) {
            return result.getRawModel().getId();
        } else if (result.getFileModel() != null) {

        MethodInfo setterInfo = findCachedMethod(beanType, "", null);
        if (setterInfo == null) {
            // Look for any method named "set" with one parameter
            Map<String, MethodInfo> classMethodCache = METHOD_CACHE.computeIfAbsent(beanType, this::buildMethodCache);
            setterInfo = classMethodCache.get("set");
        }

        if (setterInfo == null) {

        if (available != null) {
            addFieldToSource(sourceMap, "available", available);
        }
        if (crawler != null) {
            addFieldToSource(sourceMap, "crawler", crawler);
        }
        if (createdBy != null) {
            addFieldToSource(sourceMap, "createdBy", createdBy);
        }
        if (createdTime != null) {

          () -> new ToOptionalState<>(null),
          (state, o) -> state.add((o == null) ? NULL_PLACEHOLDER : o),
          ToOptionalState::combine,
          state -> {
            Object result = state.getElement();
            return (result == NULL_PLACEHOLDER) ? null : result;
          },
          Collector.Characteristics.UNORDERED);

  /**

            method.invoke(authenticator, null, groupList, roleList, groupIdsForParentLookup, "http://invalid-url-for-test");
        } catch (Exception e) {
            // Expected - null user or invalid URL
        }

        // Verify lists remain valid after error
        assertNotNull(groupList, "groupList should not be null");
        assertNotNull(roleList, "roleList should not be null");

            if (root_directory != null) {
                _dst = _dst.deferred;
                root_directory.encode(_dst);

            }
            if (object_name != null) {
                _dst = _dst.deferred;
                object_name.encode(_dst);

            }
            if (security_quality_of_service != null) {
                _dst = _dst.deferred;

  public void testSetNull() throws Exception {
    future.set(null);
    assertSuccessful(future, null);
  }

  @SuppressWarnings("nullness") // test of a bogus call
  public void testSetExceptionNull() throws Exception {
    assertThrows(NullPointerException.class, () -> future.setException(null));

    assertThat(future.isDone()).isFalse();
    assertThat(future.set(1)).isTrue();

   * removal operations, and these are reflected in the underlying table.
   *
   * <p>It's acceptable for the underlying table to contain null keys, and even null values provided
   * that the function is capable of accepting null input. The transformed table might contain null
   * values, if the function sometimes gives a null result.
   *
   * <p>The returned table is not thread-safe or serializable, even if the underlying table is.
   *