public void test_doneBeforeResolve() throws Exception {
        final Deferred<SuggestResponse> deferred = new Deferred<>();

        Thread th = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException ignore) {}
            deferred.resolve(new SuggestResponse("", 0, Collections.emptyList(), 0, null));
        });
        th.start();

    public Integer crudMode;

    @Required
    @Size(max = 1000)
    public String regex;

    @Size(max = 1000)
    public String replacement;

    @Required
    public String processType;

    @Required
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer sortOrder;

    @Size(max = 1000)
    public String createdBy;

    @ValidateTypeFailure

	}
	// List of readers used.
	readers := []io.Reader{
		// Test - 1
		bytes.NewReader([]byte("1000;chunk-signature=111123333333333333334444211\r\n")),
		// Test - 2
		bytes.NewReader([]byte("1000;")),
		// Test - 3
		bytes.NewReader([]byte(fmt.Sprintf("%4097d", 1))),
		// Test - 4
		bytes.NewReader([]byte("1000;chunk-signature=111123333333333333334444211\r\n")),
	}
	testCases := []testCase{

import jakarta.validation.constraints.Size;

/**
 * @author Keiichi Watanabe
 */
public class EditForm extends CreateForm {

    @Required
    @Size(max = 1000)
    public String id;

    @Size(max = 1000)
    public String updatedBy;

    @ValidateTypeFailure
    public Long updatedTime;

    @Required
    @ValidateTypeFailure
    public Long versionNo;

import jakarta.validation.constraints.Size;

/**
 * @author Keiichi Watanabe
 */
public class EditForm extends CreateForm {

    @Required
    @Size(max = 1000)
    public String id;

    @Size(max = 1000)
    public String updatedBy;

    @ValidateTypeFailure
    public Long updatedTime;

    @Required
    @ValidateTypeFailure
    public Integer versionNo;

        } else if (size.divide(ONE_PB_BI).compareTo(BigInteger.ZERO) > 0) {
            displaySize = new BigDecimal(size.divide(ONE_TB_BI)).divide(BigDecimal.valueOf(1000)) + "PB";
        } else if (size.divide(ONE_TB_BI).compareTo(BigInteger.ZERO) > 0) {
            displaySize = new BigDecimal(size.divide(ONE_GB_BI)).divide(BigDecimal.valueOf(1000)) + "TB";

    /**
     * @throws Exception
     */
    public void testToShort() throws Exception {
        assertEquals(new Short("1000"), ShortConversionUtil.toShort("1,000"));
    }

    /**
     * @throws Exception
     */
    public void testToPrimitiveShort() throws Exception {
        assertEquals(1000, ShortConversionUtil.toPrimitiveShort("1,000"));
    }

    /**
     * @throws Exception
     */

        fooAuth.setServer("foo");
        fooAuth.setPort(1000);
        smbAuthenticationHolder.add(fooAuth);

        assertEquals(hogeAuth, smbAuthenticationHolder.get("smb://hoge/"));
        assertEquals(fugaAuth, smbAuthenticationHolder.get("smb://fuga/"));
        assertEquals(fooAuth, smbAuthenticationHolder.get("smb://foo:1000/"));
        assertEquals(hogeAuth, smbAuthenticationHolder.get("smb://hoge/text.txt"));

        ) {
          webSocket.send(text)
        }

        override fun onClosing(
          webSocket: WebSocket,
          code: Int,
          reason: String,
        ) {
          webSocket.close(1000, null)
          latch.countDown()
        }

        override fun onFailure(
          webSocket: WebSocket,
          t: Throwable,
          response: Response?,
        ) {

        smbAuthentication = new SmbAuthentication();
        smbAuthentication.setServer("hoge");
        smbAuthentication.setPort(1000);
        assertEquals("smb://hoge:1000/", smbAuthentication.getPathPrefix());

        smbAuthentication = new SmbAuthentication();
        smbAuthentication.setPort(1000);
        assertEquals("smb://", smbAuthentication.getPathPrefix());
    }