}

    /**
     * Null pointer scenario – calls on a null reference should raise
     * {@link NullPointerException}. This test is defensive; in real code it
     * would likely be handled elsewhere.
     */
    @Test
    @DisplayName("calling getters on null reference throws NPE")
    void testNullReference() {
        AllocInfo nullRef = null;

        short level = 1;
        NdrObject nullInfo = null;

        // Act
        queryPolicy = new MsrpcQueryInformationPolicy(mockPolicyHandle, level, nullInfo);

        // Assert
        assertNotNull(queryPolicy);
        assertEquals(null, queryPolicy.info);
    }

    @Test
    void constructor_shouldAlwaysSetPtypeToZero() {
        // Arrange
        short level = 5;

        // Act

    void implementationRejectsNulls() {
        SmbFilenameFilter filter = (dir, name) -> {
            if (dir == null || name == null) {
                throw new NullPointerException("dir and name must be non-null");
            }
            return true;
        };

        NullPointerException npe1 = assertThrows(NullPointerException.class, () -> filter.accept(null, "x"));

    assertTrue("add(null) should return true", collection.add(null));
    expectAdded((E) null);
  }

  @CollectionFeature.Require(value = SUPPORTS_ADD, absent = ALLOWS_NULL_VALUES)
  public void testAdd_nullUnsupported() {
    assertThrows(NullPointerException.class, () -> collection.add(null));
    expectUnchanged();
    expectNullMissingWhenNullUnsupported("Should not contain null after unsupported add(null)");
  }

    assertTrue("add(null) should return true", collection.add(null));
    expectAdded((E) null);
  }

  @CollectionFeature.Require(value = SUPPORTS_ADD, absent = ALLOWS_NULL_VALUES)
  public void testAdd_nullUnsupported() {
    assertThrows(NullPointerException.class, () -> collection.add(null));
    expectUnchanged();
    expectNullMissingWhenNullUnsupported("Should not contain null after unsupported add(null)");
  }

          + "justo commodo quam bibendum ut gravida leo accumsan. Nullam malesuada sagittis diam, "
          + "quis suscipit mauris euismod vulputate. Pellentesque ultrices tellus sed lorem "
          + "aliquet pulvinar. Nam lorem nunc, ultrices at auctor non, scelerisque eget turpis. "
          + "Nullam eget varius erat. Sed a lorem id arcu dictum euismod. Fusce lectus odio, "

    return getAnnotation(annotationType) != null;
  }

  @Override
  public <A extends Annotation> @Nullable A getAnnotation(Class<A> annotationType) {
    checkNotNull(annotationType);
    for (Annotation annotation : annotations) {
      if (annotationType.isInstance(annotation)) {
        return annotationType.cast(annotation);
      }
    }
    return null;
  }

  @Override

                }
            }
        } finally {
            this.open = false;
            if (t != null) {
                // release tree usage
                t.release();
            }
            this.tree = null;
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbFileHandle#close()
     */
    @Override

  /**
   * Visits the given types. Null types are ignored. This allows subclasses to call {@code
   * visit(parameterizedType.getOwnerType())} safely without having to check nulls.
   */
  public final void visit(@Nullable Type... types) {
    for (Type type : types) {
      if (type == null || !visited.add(type)) {
        // null owner type, or already visited;
        continue;
      }

   * href="https://bugs.openjdk.org/browse/JDK-6409434">JDK-6409434</a> is fixed. It's unclear
   * whether nulls were to be permitted or forbidden, but presumably the eventual fix will be to
   * permit them, as it seems more likely that code would depend on that behavior than on the other.
   * Thus, we say the bug is in set(), which fails to support null.
   */
  @J2ktIncompatible
  @GwtIncompatible // reflection