&& targ.getMechanismListMIC() != null) {
                // this indicates that mechlistMIC is required by the server
                verifyMechListMIC(targ.getMechanismListMIC());
                return new NegTokenTarg(NegTokenTarg.UNSPECIFIED_RESULT, null, null, calculateMechListMIC());
            }

      }

    fun build(): Cookie =
      Cookie(
        name ?: throw NullPointerException("builder.name == null"),
        value ?: throw NullPointerException("builder.value == null"),
        expiresAt,
        domain ?: throw NullPointerException("builder.domain == null"),
        path,
        secure,
        httpOnly,
        persistent,
        hostOnly,
        sameSite,
      )
  }

        // Simulate successful RPC call
        doAnswer(invocation -> {
            MsrpcSamrOpenDomain rpc = invocation.getArgument(0);
            rpc.retval = 0; // Success
            return null;
        }).when(mockDcerpcHandle).sendrecv(any(MsrpcSamrOpenDomain.class));

        // Act
        SamrDomainHandle handle = new SamrDomainHandle(mockDcerpcHandle, mockPolicyHandle, access, mockSid);

        // Assert

        assertEquals(0, result);
    }

    @Test
    @DisplayName("Test all read methods with null buffer")
    void testReadMethodsWithNullBuffer() {
        // Even with null buffer, methods should return 0 without throwing exception
        int result = response.readSetupWireFormat(null, 0, 0);
        assertEquals(0, result);

        result = response.readParametersWireFormat(null, 0, 0);

    ImmutableList.Builder<String> builder = ImmutableList.builder();
    assertThrows(NullPointerException.class, () -> builder.add((String) null));

    assertThrows(NullPointerException.class, () -> builder.add((String[]) null));

    assertThrows(NullPointerException.class, () -> builder.add("a", null, "b"));
  }

  public void testBuilderAddAllHandlesNullsCorrectly() {
    {

        }
        return rule;
    }

    public static UserDictionary getUserDictionary(Environment env, Settings settings) {
        if (settings.get(USER_DICT_PATH_OPTION) != null && settings.get(USER_DICT_RULES_OPTION) != null) {
            throw new IllegalArgumentException(
                    "It is not allowed to use [" + USER_DICT_PATH_OPTION + "] in conjunction" + " with [" + USER_DICT_RULES_OPTION + "]");
        }

        // Test constructor with null message
        GsaConfigException exception = new GsaConfigException(null);

        assertNotNull(exception);
        assertNull(exception.getMessage());
        assertNull(exception.getCause());
    }

    public void test_constructorWithNullMessageAndCause() {
        // Test constructor with null message and null cause

        JobProcess jobProcess = new JobProcess(mockProcess, 0, null);

        assertNotNull(jobProcess.getInputStreamThread());
    }

    public void test_constructor_withNullCallback() throws IOException {
        Process mockProcess = createMockProcess("test");
        JobProcess jobProcess = new JobProcess(mockProcess, 10, null);

        assertNotNull(jobProcess.getInputStreamThread());
    }

            initProtocolVersions((DialectVersion) null, null);
        }

        if (this.disallowCompound == null) {
            // Samba woes on these
            // Smb2SessionSetupRequest + X -> INTERNAL_ERROR
            // Smb2TreeConnectRequest + IoCtl -> NETWORK_NAME_DELETED
            this.disallowCompound = new HashSet<>(Arrays.asList("Smb2SessionSetupRequest", "Smb2TreeConnectRequest"));

        .onRequestStart(CloseSocket())
        .build(),
    )
    val webSocket = newWebSocket()
    clientListener.assertFailure(
      101,
      null,
      ProtocolException::class.java,
      "Expected 'Connection' header value 'Upgrade' but was 'null'",
    )
    webSocket.cancel()
  }

  @Test
  @Throws(IOException::class)
  fun wrongConnectionHeader() {
    webServer.enqueue(