public void testGetRandomAccess() {
    Multimap<String, Integer> multimap = create();
    multimap.put("foo", 1);
    multimap.put("foo", 3);
    assertTrue(multimap.get("foo") instanceof RandomAccess);
    assertTrue(multimap.get("bar") instanceof RandomAccess);
  }

  /** Confirm that removeAll() returns a List implementing RandomAccess. */
  public void testRemoveAllRandomAccess() {

 *
 */
public class ByteConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToByte() throws Exception {
        assertEquals(Byte.valueOf("100"), ByteConversionUtil.toByte("100"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveByte() throws Exception {
        assertEquals(100, ByteConversionUtil.toPrimitiveByte("100"));
    }

    /**

 */
public class DoubleConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToDouble() throws Exception {
        assertEquals(Double.valueOf("1000.5"), DoubleConversionUtil.toDouble("1,000.5"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveDouble() throws Exception {
        assertEquals(1000.5, DoubleConversionUtil.toPrimitiveDouble("1,000.5"), 0);

 */
public class FloatConversionUtilTest extends TestCase {

    /**
     * @throws Exception
     */
    public void testToFloat() throws Exception {
        assertEquals(Float.valueOf("1000.5"), FloatConversionUtil.toFloat("1,000.5"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveFloat() throws Exception {
        assertEquals(1000.5, FloatConversionUtil.toPrimitiveFloat("1,000.5"), 0);
    }

    public void test_constructorWithMessage() {
        // Test constructor with message only
        String message = "Test scheduled job error";
        ScheduledJobException exception = new ScheduledJobException(message);

        assertEquals(message, exception.getMessage());
        assertNull(exception.getCause());
    }

    public void test_constructorWithMessageAndCause() {

  @CollectionSize.Require(absent = ZERO)
  public void testAddAllAtIndex_supportedAllPresent() {
    assertTrue(
        "addAll(n, allPresent) should return true",
        getList().addAll(0, MinimalCollection.of(e0())));
    expectAdded(0, e0());
  }

  @ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
  @CollectionSize.Require(absent = ZERO)
  public void testAddAllAtIndex_unsupportedAllPresent() {
    assertThrows(

    }

    @Test
    void testGetVersionReturnsResolvedVersionOnSnapshot() {
        assertEquals(snapshotResolvedVersion, snapshotArtifact.getVersion());

        // this is FOUL!
        //        snapshotArtifact.isSnapshot();

        assertEquals(snapshotSpecVersion, snapshotArtifact.getBaseVersion());
    }

    @Test
    void testGetDependencyConflictId() {

    public void insert(ScheduledJob entity) {
        doInsert(entity, null);
    }

    public void insert(ScheduledJob entity, RequestOptionCall<IndexRequestBuilder> opLambda) {
        entity.asDocMeta().indexOption(opLambda);
        doInsert(entity, null);
    }

    public void update(ScheduledJob entity) {
        doUpdate(entity, null);
    }

    private final String workstation = "TEST_WORKSTATION";

    @BeforeEach
    void setUp() {
        // MockitoExtension handles mock initialization
        // Type1Message.getDefaultWorkstation() is static, so we can't easily mock it without PowerMock.
        // We will proceed assuming it returns a predictable value or handle it as is.
    }

    @Test
    void testConstructor_withSigning() {
        // Test constructor when signing is enabled

        lenient().when(mockConfig.isWitnessServiceDiscovery()).thenReturn(true);
    }

    @AfterEach
    void tearDown() {
        if (mockService != null) {
            mockService.close();
        }
    }

    @Test
    void testMockServiceLifecycle() throws Exception {
        assertNotNull(mockService.getAddress());
        assertTrue(mockService.getPort() > 0);