testEnv.put("test.key", "test.value");
        ldapUser = new LdapUser(testEnv, "testuser");

        ComponentUtil.register(new SystemHelper(), "systemHelper");

        // Register a mock LdapManager to avoid NPE
        ComponentUtil.register(new LdapManager() {
            // Override methods that are called in tests
        }, "ldapManager");
    }

    @Override

     * package-private, I feel OK with just not testing them for NPE.
     *
     * Note that testing casValue is particularly dangerous because it uses Unsafe under some
     * versions of Java, and apparently Unsafe can cause SIGSEGV instead of NPE—almost as if it's
     * not safe.
     */
    concat(
            stream(AbstractFuture.class.getDeclaredMethods()),

    void resolveSids_invalidInputs() throws Exception {
        SIDCacheImpl cache = new SIDCacheImpl(mock(CIFSContext.class));
        CIFSContext ctx = mock(CIFSContext.class);

        // Null sids array -> NPE
        assertThrows(NullPointerException.class, () -> cache.resolveSids(ctx, "server", null, 0, 1));

        // Bad offset/length leads to ArrayIndexOutOfBoundsException

            assertTrue(ex.getMessage().contains("domain sid"));
        }

        @Test
        @DisplayName("Static toByteArray null input throws NPE")
        void testStaticToByteArrayNull() {
            assertThrows(NullPointerException.class, () -> SID.toByteArray(null));
        }
    }

    @Nested
    @DisplayName("Tests requiring mocks")

    }

    @Override
    public Artifact find(Artifact artifact) {
        File artifactFile = new File(getBasedir(), pathOf(artifact));

        // We need to set the file here or the resolver will fail with an NPE, not fully equipped to deal
        // with multiple local repository implementations yet.
        artifact.setFile(artifactFile);

        return artifact;
    }

    @Override

        assertEquals(lastName.toUpperCase(), writtenLastName);
    }

    @Test
    @DisplayName("Test writeParametersWireFormat with null lastName for NET_SERVER_ENUM3 throws NPE")
    void testWriteParametersWireFormatNetServerEnum3NullLastName() throws Exception {
        String domain = "WORKGROUP";
        int serverTypes = NetServerEnum2.SV_TYPE_ALL;

        // Mock configuration methods
        when(mockConfig.getPid()).thenReturn(1234);
        when(mockCifsContext.getConfig()).thenReturn(mockConfig);

        // Mock credentials to prevent NPE
        when(mockCredentials.getUserDomain()).thenReturn("DOMAIN");
        when(mockCifsContext.getCredentials()).thenReturn(mockCredentials);

        // Create URL handler

    ContainsBothWithMultisetFirst reMultisetFirst = reserialize(multisetFirst);
    assertThat(reMultisetFirst.a.isEmpty()).isFalse();
    // The following NPE is a side effect of our changes to avoid mutating `final` fields.
    assertThrows(NullPointerException.class, () -> reMultisetFirst.z.multiset.isEmpty());

    ContainsBothWithContainsMultisetFirst reContainsMultisetFirst =

        void testToStringWithNullBinding() {
            // Given: Handle with null binding
            TestDcerpcHandle handleWithNullBinding = new TestDcerpcHandle(mockContext);

            // When/Then: Should throw NPE for null binding (expected behavior)
            assertThrows(NullPointerException.class, () -> handleWithNullBinding.toString());
        }

        @Test
        @DisplayName("Should handle session key retrieval")

  public void testConstructor() {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i = 0; i < SIZE; i++) {
      assertBitEquals(0.0, aa.get(i));
    }
  }

  /** constructor with null array throws NPE */
  public void testConstructor2NPE() {
    double[] a = null;
    assertThrows(NullPointerException.class, () -> new AtomicDoubleArray(a));
  }

  /** constructor with array is of same size and has all elements */