dataStoreParams.put("key2", 123);
        assertEquals(123, dataStoreParams.get("key2"));

        dataStoreParams.put("key3", null);
        assertNull(dataStoreParams.get("key3"));
    }

    // Test get for non-existent key
    public void test_getNonExistentKey() {
        assertNull(dataStoreParams.get("nonexistent"));
    }

    // Test getAsString with String value
    public void test_getAsStringWithStringValue() {

public class MapComputeIfPresentTester<K, V> extends AbstractMapTester<K, V> {

  @MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfPresent_supportedAbsent() {
    assertNull(
        "computeIfPresent(notPresent, function) should return null",
        getMap()
            .computeIfPresent(
                k3(),
                (k, v) -> {
                  throw new AssertionFailedError();

        assertNull(source.getPath());
        assertEquals(location, source.getLocation());
        assertNull(source.resolve("subdir"));

        ModelSource.ModelLocator locator = mock(ModelSource.ModelLocator.class);
        assertNull(source.resolve(locator, "subproject"));
        verify(locator, never()).locateExistingPom(any(Path.class));

        assertEquals(NegTokenTarg.ACCEPT_INCOMPLETE, parsed.getResult(), "result should be present");
        assertNull(parsed.getMechanism(), "mechanism should be null when omitted");
        assertNull(parsed.getMechanismToken(), "mechanism token should be null when omitted");
        assertNull(parsed.getMechanismListMIC(), "MIC should be null when omitted");
    }

    @Test

package jcifs.smb1.http;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.security.Principal;

  }

  public void testGet_constantWithGenericsNotUsed() {
    assertNull(ArbitraryInstances.get(WithGenericConstant.class));
  }

  public void testGet_nullConstant() {
    assertNull(ArbitraryInstances.get(WithNullConstant.class));
  }

  public void testGet_constantTypeDoesNotMatch() {
    assertNull(ArbitraryInstances.get(ParentClassHasConstant.class));
  }

package jcifs.util.transport;

import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class MessageTest {

    private Message message;

    @BeforeEach
    void setUp() {

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

        assertNull(task);
    }

    public void test_createTask_withEmptyPath() {
        // Test task creation with empty path
        Map<String, Object> docMap = new HashMap<>();
        docMap.put("mimetype", "application/pdf");

        Tuple3<String, String, String> task = thumbnailGenerator.createTask("", docMap);
        assertNull(task);
    }

    void testConstructorWithoutAndx() {
        testBlock = new TestAndXServerMessageBlock(mockConfig, (byte) 0x25);

        assertNull(testBlock.getAndx());
        assertNull(testBlock.getNext());
        assertNull(testBlock.getNextResponse());
    }

    @Test
    @DisplayName("Test constructor with null andx command")
    void testConstructorWithNullAndx() {