method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
JobDataMapper { public JobData transform(JobDescriptor jobDescriptor, SimpleDateFormat dateTimeFormat) { JobData.Builder builder = new JobData.Builder(); builder.withId(jobDescriptor.getId()); builder.withLabel(jobDescriptor.getLabel()); builder.withDescription(jobDescriptor.getDescription()); builder.withVersion(jobDescriptor.getVersion()); builder.withLabel(jobDescriptor.getLabel()); builder.withUsername(jobDescriptor.getUsername()); Date creationDate; try { creationDate = dateTimeFormat.parse(jobDescriptor.getCreationDate()); } catch (ParseException e) { creationDate = null; } builder.withCreationDate(creationDate); Collection<String> outputFormat = jobDescriptor.getOutputFormats().getOutputFormat(); List<JobOutputFormat> formats = new ArrayList<>(outputFormat.size()); for (String format : outputFormat) { formats.add(JobOutputFormat.valueOf(format)); } builder.withOutputFormats(formats); return builder.build(); } JobData transform(JobDescriptor jobDescriptor, SimpleDateFormat dateTimeFormat); }### Answer:
@Test public void testTransform() throws Exception { long creationTime = DATE_FORMAT.parse("2013-10-03 16:32:05").getTime(); JobData jobData = jobDataMapper.transform(mJobDescriptor, DATE_FORMAT); assertThat("Should map id", jobData.getId(), is(20)); assertThat("Should map version", jobData.getVersion(), is(2)); assertThat("Should map username", jobData.getUsername(), is("user")); assertThat("Should map label", jobData.getLabel(), is("label")); assertThat("Should map description", jobData.getDescription(), is("description")); assertThat("Should map creation date", jobData.getCreationDate().getTime(), is(creationTime)); assertThat("Should map description", jobData.getOutputFormats(), hasItem(JobOutputFormat.HTML)); } |
### Question:
JobUnitDateParser { @Nullable abstract Date parseDate(String rawDate); }### Answer:
@Test public void should_parse_without_milliseconds() throws Exception { parser.parseDate(PREVIOUS_FIRE_TIME); }
@Test public void should_parse_with_milliseconds() throws Exception { parser.parseDate(NEXT_FIRE_TIME); } |
### Question:
AttachmentsFactory { public List<ReportAttachment> create(ExportDescriptor export, String execId) { String exportId = export.getId(); Set<AttachmentDescriptor> rawAttachments = export.getAttachments(); List<ReportAttachment> attachments = new ArrayList<>(rawAttachments.size()); for (AttachmentDescriptor attachment : rawAttachments) { String fileName = attachment.getFileName(); ReportAttachment reportAttachment = new ReportAttachment( mExportExecutionApi, execId, exportId, fileName ); attachments.add(reportAttachment); } return attachments; } AttachmentsFactory(ExportExecutionApi exportExecutionApi); List<ReportAttachment> create(ExportDescriptor export, String execId); }### Answer:
@Test public void testCreate() throws Exception { when(mExportDescriptor.getId()).thenReturn(EXPORT_ID); when(mAttachmentDescriptor.getFileName()).thenReturn(ATTACHMENT_ID); when(mExportDescriptor.getAttachments()).thenReturn(Collections.singleton(mAttachmentDescriptor)); List<ReportAttachment> result = attachmentsFactory.create(mExportDescriptor, EXEC_ID); assertThat(result.size(), is(1)); verify(mExportDescriptor).getId(); verify(mExportDescriptor).getAttachments(); verify(mAttachmentDescriptor).getFileName(); } |
### Question:
ExportExecutionApi { public ExportExecutionDescriptor start(String execId, ReportExportOptions reportExportOptions) throws ServiceException { ExecutionRequestOptions options = mExportOptionsMapper.transform(reportExportOptions); try { return mReportExportRestApi.runExportExecution(execId, options); } catch (HttpException e) { throw mExceptionMapper.transform(e); } catch (IOException e) { throw mExceptionMapper.transform(e); } } ExportExecutionApi(ServiceExceptionMapper exceptionMapper,
ReportExportRestApi reportExportRestApi,
ExportOptionsMapper exportOptionsMapper,
ReportExportMapper reportExportMapper,
AttachmentExportMapper attachmentExportMapper); ExportExecutionDescriptor start(String execId, ReportExportOptions reportExportOptions); ExecutionStatus awaitReadyStatus(String execId, String exportId, String reportUri, long delay); ReportExportOutput downloadExport(String execId, String exportId); ResourceOutput downloadAttachment(String execId, String exportId, String attachmentId); }### Answer:
@Test public void testStart() throws Exception { when(mExportOptionsMapper.transform(any(ReportExportOptions.class))).thenReturn(mExecutionRequestOptions); ReportExportOptions criteria = FakeOptions.export(); exportExecutionApi.start(EXEC_ID, criteria); verify(mReportExportRestApi).runExportExecution(EXEC_ID, mExecutionRequestOptions); } |
### Question:
ExportExecutionApi { public ReportExportOutput downloadExport(String execId, String exportId) throws ServiceException { try { ExportOutputResource result = mReportExportRestApi.requestExportOutput(execId, exportId); return mReportExportMapper.transform(result); } catch (HttpException e) { throw mExceptionMapper.transform(e); } catch (IOException e) { throw mExceptionMapper.transform(e); } } ExportExecutionApi(ServiceExceptionMapper exceptionMapper,
ReportExportRestApi reportExportRestApi,
ExportOptionsMapper exportOptionsMapper,
ReportExportMapper reportExportMapper,
AttachmentExportMapper attachmentExportMapper); ExportExecutionDescriptor start(String execId, ReportExportOptions reportExportOptions); ExecutionStatus awaitReadyStatus(String execId, String exportId, String reportUri, long delay); ReportExportOutput downloadExport(String execId, String exportId); ResourceOutput downloadAttachment(String execId, String exportId, String attachmentId); }### Answer:
@Test public void testDownloadExport() throws Exception { when(mReportExportRestApi.requestExportOutput(anyString(), anyString())).thenReturn(export); exportExecutionApi.downloadExport(EXEC_ID, EXPORT_ID); verify(mReportExportRestApi).requestExportOutput(EXEC_ID, EXPORT_ID); verify(mReportExportMapper).transform(export); } |
### Question:
ExportExecutionApi { public ResourceOutput downloadAttachment(String execId, String exportId, String attachmentId) throws ServiceException { try { OutputResource result = mReportExportRestApi.requestExportAttachment(execId, exportId, attachmentId); return mAttachmentExportMapper.transform(result); } catch (HttpException e) { throw mExceptionMapper.transform(e); } catch (IOException e) { throw mExceptionMapper.transform(e); } } ExportExecutionApi(ServiceExceptionMapper exceptionMapper,
ReportExportRestApi reportExportRestApi,
ExportOptionsMapper exportOptionsMapper,
ReportExportMapper reportExportMapper,
AttachmentExportMapper attachmentExportMapper); ExportExecutionDescriptor start(String execId, ReportExportOptions reportExportOptions); ExecutionStatus awaitReadyStatus(String execId, String exportId, String reportUri, long delay); ReportExportOutput downloadExport(String execId, String exportId); ResourceOutput downloadAttachment(String execId, String exportId, String attachmentId); }### Answer:
@Test public void testDownloadAttachment() throws Exception { when(mReportExportRestApi.requestExportAttachment(anyString(), anyString(), anyString())).thenReturn(attachment); exportExecutionApi.downloadAttachment(EXEC_ID, EXPORT_ID, ATTACHMENT_ID); verify(mReportExportRestApi).requestExportAttachment(EXEC_ID, EXPORT_ID, ATTACHMENT_ID); verify(mAttachmentExportMapper).transform(attachment); } |
### Question:
ExportFactory { @NotNull public ReportExport create(ReportExecutionDescriptor descriptor, String execId, ExportIdWrapper exportIdWrapper) throws ServiceException { ExportDescriptor export = findExportDescriptor(descriptor, exportIdWrapper.getServerId()); if (export == null) { throw new ServiceException("Server returned malformed export details", null, StatusCodes.EXPORT_EXECUTION_FAILED); } List<ReportAttachment> attachments = mAttachmentsFactory.create(export, execId); return new ReportExport(mExportExecutionApi, attachments, execId, exportIdWrapper.getExactId()); } ExportFactory(ExportExecutionApi exportExecutionApi, AttachmentsFactory attachmentsFactory); @NotNull ReportExport create(ReportExecutionDescriptor descriptor, String execId, ExportIdWrapper exportIdWrapper); }### Answer:
@Test public void should_create_export_if_details_fulfilled() throws Exception { ReportExport result = exportFactory.create(mReportExecutionDescriptor, EXEC_ID, mExportIdWrapper); assertThat(result, is(notNullValue())); assertThat(result, is(instanceOf(ReportExport.class))); verify(mAttachmentsFactory).create(mExportDescriptor, EXEC_ID); }
@Test public void should_throw_if_details_missing() throws Exception { when(mExportDescriptor.getId()).thenReturn("123122"); try { exportFactory.create(mReportExecutionDescriptor, EXEC_ID, mExportIdWrapper); fail("Should throw ServiceException"); } catch (ServiceException ex) { assertThat(ex.getMessage(), is("Server returned malformed export details")); assertThat(ex.code(), is(StatusCodes.EXPORT_EXECUTION_FAILED)); } } |
### Question:
AbstractReportExecution extends ReportExecution { @NotNull @Override public final ReportMetadata waitForReportCompletion() throws ServiceException { mReportExecutionApi.awaitStatus(mExecId, mReportUri, mDelay, Status.ready()); ReportExecutionDescriptor reportDescriptor = mReportExecutionApi.getDetails(mExecId); return new ReportMetadata(mReportUri, reportDescriptor.getTotalPages()); } protected AbstractReportExecution(ReportExecutionApi reportExecutionApi,
String execId,
String reportUri,
long delay); @NotNull @Override final ReportMetadata waitForReportCompletion(); @NotNull @Override final ReportExport export(@NotNull ReportExportOptions options); @NotNull final ReportExecution updateExecution(@Nullable List<ReportParameter> newParameters); @NotNull @Override String getExecutionId(); }### Answer:
@Test public void testWaitForReportCompletion() throws Exception { ReportMetadata metadata = abstractReportExecution.waitForReportCompletion(); assertThat("Failed to create report metadata with exact total pages", metadata.getUri(), is(REPORT_URI)); assertThat("Failed to create report metadata with exact report uri", metadata.getTotalPages(), is(TOTAL_PAGES)); verify(mReportExecutionApi).awaitStatus(EXEC_ID, REPORT_URI, 0, Status.ready()); verify(mReportExecutionApi).getDetails(EXEC_ID); } |
### Question:
AbstractReportExecution extends ReportExecution { @NotNull @Override public final ReportExport export(@NotNull ReportExportOptions options) throws ServiceException { Preconditions.checkNotNull(options, "Export options should not be null"); return doExport(options); } protected AbstractReportExecution(ReportExecutionApi reportExecutionApi,
String execId,
String reportUri,
long delay); @NotNull @Override final ReportMetadata waitForReportCompletion(); @NotNull @Override final ReportExport export(@NotNull ReportExportOptions options); @NotNull final ReportExecution updateExecution(@Nullable List<ReportParameter> newParameters); @NotNull @Override String getExecutionId(); }### Answer:
@Test public void should_not_run_export_with_null_options() throws Exception { expected.expect(NullPointerException.class); expected.expectMessage("Export options should not be null"); abstractReportExecution.export(null); } |
### Question:
ExportOptionsMapper5_5 extends ExportOptionsMapper { @Override public ExecutionRequestOptions transform(ReportExportOptions criteria) { ExecutionRequestOptions options = super.transform(criteria); options.withIgnorePagination(null); options.withBaseUrl(null); options.withMarkupType(null); return options; } ExportOptionsMapper5_5(String baseUrl); @Override ExecutionRequestOptions transform(ReportExportOptions criteria); }### Answer:
@Test public void should_exclude_ignore_pagination_flag() throws Exception { ReportExportOptions criteria = ReportExportOptions.builder() .withFormat(ReportFormat.PDF) .withIgnorePagination(true) .build(); ExecutionRequestOptions options = mapper.transform(criteria); assertThat("Failed to remove 'ignorePagination' option", options.getIgnorePagination(), is(nullValue())); }
@Test public void should_exclude_base_url() throws Exception { ReportExportOptions criteria = ReportExportOptions.builder() .withFormat(ReportFormat.PDF) .withIgnorePagination(true) .build(); ExecutionRequestOptions options = mapper.transform(criteria); assertThat("Failed to remove 'baseUrl' option", options.getBaseUrl(), is(nullValue())); } |
### Question:
ProxyReportService extends ReportService { @NotNull @Override public ReportExecution run(@Nullable String reportUri, @Nullable ReportExecutionOptions execOptions) throws ServiceException { Preconditions.checkNotNull(reportUri, "Report uri should not be null"); if (execOptions == null) { execOptions = ReportExecutionOptions.builder().build(); } return getDelegate().run(reportUri, execOptions); } ProxyReportService(ReportServiceFactory serviceFactory); @NotNull @Override ReportExecution run(@Nullable String reportUri,
@Nullable ReportExecutionOptions execOptions); }### Answer:
@Test public void should_not_run_with_null_uri() throws Exception { expected.expect(NullPointerException.class); expected.expectMessage("Report uri should not be null"); proxyReportService.run(null, null); }
@Test public void should_delegate_run_call() throws Exception { proxyReportService.run(REPORT_URI, null); verify(mReportServiceFactory).newService(); verify(mReportService).run(eq(REPORT_URI), any(ReportExecutionOptions.class)); } |
### Question:
ReportService { @NotNull public static ReportService newService(@NotNull AuthorizedClient client) { Preconditions.checkNotNull(client, "Client should not be null"); InfoCacheManager cacheManager = InfoCacheManager.create(client); ServiceExceptionMapper reportMapper = ReportExceptionMapper.getInstance(); ReportServiceFactory reportServiceFactory = new ReportServiceFactory(cacheManager, client.reportExecutionApi(), client.reportExportApi(), reportMapper, client.getBaseUrl(), TimeUnit.SECONDS.toMillis(1) ); return new ProxyReportService(reportServiceFactory); } @NotNull abstract ReportExecution run(@NotNull String reportUri,
@Nullable ReportExecutionOptions execOptions); @NotNull static ReportService newService(@NotNull AuthorizedClient client); }### Answer:
@Test public void should_create_proxy_instance() throws Exception { ReportService service = ReportService.newService(mClient); assertThat("Should be instance of proxy service", service, is(instanceOf(ProxyReportService.class))); assertThat(service, is(notNullValue())); }
@Test public void should_reject_null_client() throws Exception { expected.expectMessage("Client should not be null"); expected.expect(NullPointerException.class); ReportService.newService(null); } |
### Question:
ReportExportMapper { public ReportExportOutput transform(final ExportOutputResource outputResource) { return new ReportExportOutput() { @Override public boolean isFinal() { return outputResource.isFinal(); } @Override public PageRange getPages() { return PageRange.parse(outputResource.getPages()); } @Override public InputStream getStream() throws IOException { return outputResource.getOutputResource().getStream(); } }; } ReportExportOutput transform(final ExportOutputResource outputResource); }### Answer:
@Test public void testTransform() throws Exception { when(mExportOutputResource.getPages()).thenReturn(TOTAL_PAGES); when(mExportOutputResource.isFinal()).thenReturn(Boolean.FALSE); when(mOutput.getStream()).thenReturn(mStream); when(mExportOutputResource.getOutputResource()).thenReturn(mOutput); ReportExportOutput export = mapper.transform(mExportOutputResource); assertThat(export.getPages(), is(PAGE_RANGE)); assertThat(export.isFinal(), is(Boolean.FALSE)); assertThat(export.getStream(), is(mStream)); } |
### Question:
ExportIdWrapper { public abstract String getExactId(); abstract String getServerId(); abstract String getExactId(); final void wrap(ExportExecutionDescriptor exportDetails, ReportExportOptions options); }### Answer:
@Test public void should_generate_specific_exact_id_for_5_5() throws Exception { giveExportDetailsWithId(); givenExportForFirstHtmlPage(); givenConfigured5_5Wrapper(); String exactId = mWrapper5_5.getExactId(); assertThat(exactId, is("HTML;pages=1")); }
@Test public void should_generate_specific_exact_id_for_5_6Plus() throws Exception { giveExportDetailsWithId(); givenExportForFirstHtmlPage(); givenConfigured5_6PlusWrapper(); String exactId = mWrapper5_6Plus.getExactId(); assertThat(exactId, is(EXPORT_ID)); } |
### Question:
ExportIdWrapper { public abstract String getServerId(); abstract String getServerId(); abstract String getExactId(); final void wrap(ExportExecutionDescriptor exportDetails, ReportExportOptions options); }### Answer:
@Test public void should_return_export_descriptor_id_for_5_5() throws Exception { giveExportDetailsWithId(); givenConfigured5_5Wrapper(); String serverId = mWrapper5_5.getServerId(); assertThat(serverId, is(EXPORT_ID)); }
@Test public void should_return_export_descriptor_id_for_5_6Plus() throws Exception { giveExportDetailsWithId(); givenConfigured5_6PlusWrapper(); String serverId = mWrapper5_6Plus.getServerId(); assertThat(serverId, is(EXPORT_ID)); } |
### Question:
RetryReportExecution extends ReportExecution { @NotNull @Override public ReportExport export(@NotNull ReportExportOptions options) throws ServiceException { try { return mDelegate.export(options); } catch (ServiceException ex) { boolean isCancelled = (ex.code() == StatusCodes.EXPORT_EXECUTION_CANCELLED || ex.code() == StatusCodes.REPORT_EXECUTION_CANCELLED); if (isCancelled) { return mDelegate.export(options); } throw ex; } } RetryReportExecution(ReportExecution delegate); @NotNull @Override ReportExport export(@NotNull ReportExportOptions options); @NotNull @Override ReportMetadata waitForReportCompletion(); @NotNull @Override ReportExecution updateExecution(@Nullable List<ReportParameter> newParameters); @NotNull @Override String getExecutionId(); }### Answer:
@Test public void should_retry_export_if_cancelled_on_first_run() throws Exception { when(mDelegate.export(any(ReportExportOptions.class))).then(crashOnFirstRun()); reportExecution.export(EXPORT_CRITERIA); verify(mDelegate, times(2)).export(EXPORT_CRITERIA); }
@Test(expected = ServiceException.class) public void should_throw_if_cancelled_on_second_run() throws Exception { when(mDelegate.export(any(ReportExportOptions.class))).thenThrow(CANCELLED_EXCEPTION); reportExecution.export(EXPORT_CRITERIA); } |
### Question:
RetryReportExecution extends ReportExecution { @NotNull @Override public ReportMetadata waitForReportCompletion() throws ServiceException { return mDelegate.waitForReportCompletion(); } RetryReportExecution(ReportExecution delegate); @NotNull @Override ReportExport export(@NotNull ReportExportOptions options); @NotNull @Override ReportMetadata waitForReportCompletion(); @NotNull @Override ReportExecution updateExecution(@Nullable List<ReportParameter> newParameters); @NotNull @Override String getExecutionId(); }### Answer:
@Test public void should_delegate_waitForReportCompletion() throws Exception { reportExecution.waitForReportCompletion(); verify(mDelegate).waitForReportCompletion(); } |
### Question:
RetryReportExecution extends ReportExecution { @NotNull @Override public ReportExecution updateExecution(@Nullable List<ReportParameter> newParameters) throws ServiceException { return mDelegate.updateExecution(newParameters); } RetryReportExecution(ReportExecution delegate); @NotNull @Override ReportExport export(@NotNull ReportExportOptions options); @NotNull @Override ReportMetadata waitForReportCompletion(); @NotNull @Override ReportExecution updateExecution(@Nullable List<ReportParameter> newParameters); @NotNull @Override String getExecutionId(); }### Answer:
@Test public void should_delegate_updateExecution() throws Exception { reportExecution.updateExecution(REPORT_PARAMS); verify(mDelegate).updateExecution(REPORT_PARAMS); } |
### Question:
AbstractReportService extends ReportService { @NotNull @Override public final ReportExecution run(@NotNull String reportUri, @NotNull ReportExecutionOptions execOptions) throws ServiceException { ReportExecutionDescriptor descriptor = mReportExecutionApi.start(reportUri, execOptions); String executionId = descriptor.getExecutionId(); mReportExecutionApi.awaitStatus(executionId, reportUri, mDelay, Status.execution(), Status.ready()); return buildExecution(reportUri, executionId, execOptions); } protected AbstractReportService(ExportExecutionApi exportExecutionApi,
ReportExecutionApi reportExecutionApi,
ExportFactory exportFactory,
long delay); @NotNull @Override final ReportExecution run(@NotNull String reportUri, @NotNull ReportExecutionOptions execOptions); }### Answer:
@Test public void testRun() throws Exception { ReportExecutionOptions criteria = ReportExecutionOptions.builder().build(); reportService.run(REPORT_URI, criteria); verify(mReportExecutionApi).start(REPORT_URI, criteria); verify(mReportExecutionApi).awaitStatus(EXEC_ID, REPORT_URI, 0, execution(), ready()); verify(reportService).buildExecution(REPORT_URI, EXEC_ID, criteria); } |
### Question:
AttachmentExportMapper { public ResourceOutput transform(final OutputResource resource) { return new ResourceOutput() { @Override public InputStream getStream() throws IOException { return resource.getStream(); } }; } ResourceOutput transform(final OutputResource resource); }### Answer:
@Test public void testTransform() throws Exception { when(mOutputResource.getStream()).thenReturn(mStream); ResourceOutput result = mapper.transform(mOutputResource); assertThat(result.getStream(), is(mStream)); } |
### Question:
ReportLookup extends ResourceLookup { @Override public String getResourceType() { return "reportUnit"; } ReportLookup(); @Override String getResourceType(); boolean alwaysPromptControls(); @Override String toString(); }### Answer:
@Test public void shouldAlwaysReturnReportUnitUriAsType() { ReportLookup response = new ReportLookup(); assertThat(response.getResourceType(), is("reportUnit")); } |
### Question:
ReportParameter { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; ReportParameter that = (ReportParameter) o; if (name != null ? !name.equals(that.name) : that.name != null) return false; if (value != null ? !value.equals(that.value) : that.value != null) return false; return true; } ReportParameter(String name, Set<String> value); String getName(); Set<String> getValue(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer:
@Test public void testEquals() throws Exception { EqualsVerifier.forClass(ReportParameter.class).verify(); } |
### Question:
ReportExecutionRequestOptions extends ExecutionRequestOptions { public static ReportExecutionRequestOptions newRequest(String uri) { if (uri == null) { throw new IllegalArgumentException("Uri should not be null"); } return new ReportExecutionRequestOptions(uri); } private ReportExecutionRequestOptions(String reportUnitUri); static ReportExecutionRequestOptions newRequest(String uri); String getReportUnitUri(); }### Answer:
@Test public void factoryMethodShouldNotAllowNull() { mExpectedException.expect(IllegalArgumentException.class); ReportExecutionRequestOptions.newRequest(null); } |
### Question:
ServerRestApi { @NotNull public ServerInfoData requestServerInfo() throws IOException, HttpException { HttpUrl httpUrl = mClientWrapper.getBaseUrl().resolve("rest_v2/serverInfo"); Request request = new Request.Builder() .addHeader("Accept", "application/json; charset=UTF-8") .url(httpUrl) .get() .build(); Response response = mClientWrapper.makeCall(request); return mClientWrapper.deserializeJson(response, ServerInfoData.class); } ServerRestApi(NetworkClient networkClient); @NotNull ServerInfoData requestServerInfo(); @NotNull String requestBuild(); @NotNull String requestEdition(); @NotNull String requestVersion(); @NotNull String requestFeatures(); @NotNull String requestEditionName(); @NotNull String requestLicenseType(); @NotNull String requestExpiration(); @NotNull String requestDateFormatPattern(); @NotNull String requestDateTimeFormatPattern(); }### Answer:
@Test public void shouldThroughRestErrorForHttpError() throws Exception { mExpectedException.expect(HttpException.class); mWebMockRule.enqueue(MockResponseFactory.create500()); objectUnderTest.requestServerInfo(); }
@Test public void shouldBuildAppropriateJsonRequestForServerInfo() throws Exception { mWebMockRule.enqueue( MockResponseFactory.create200().setBody("{}") ); ServerInfoData serverInfoData = objectUnderTest.requestServerInfo(); assertThat("Response not null value", serverInfoData, is(notNullValue())); RecordedRequest recordedRequest = mWebMockRule.get().takeRequest(); assertThat("Should accept json header", recordedRequest, containsHeader("Accept", "application/json; charset=UTF-8")); assertThat("Should have path '/rest_v2/serverInfo'", recordedRequest, hasPath("/rest_v2/serverInfo")); } |
### Question:
ServerRestApi { @NotNull public String requestBuild() throws IOException, HttpException { return plainRequest("rest_v2/serverInfo/build"); } ServerRestApi(NetworkClient networkClient); @NotNull ServerInfoData requestServerInfo(); @NotNull String requestBuild(); @NotNull String requestEdition(); @NotNull String requestVersion(); @NotNull String requestFeatures(); @NotNull String requestEditionName(); @NotNull String requestLicenseType(); @NotNull String requestExpiration(); @NotNull String requestDateFormatPattern(); @NotNull String requestDateTimeFormatPattern(); }### Answer:
@Test public void shouldHandlePlainTextResponseForBuild() throws Exception { mWebMockRule.enqueue( MockResponseFactory.create200().setBody("Enterprise for AWS") ); String editionName = objectUnderTest.requestBuild(); assertThat(editionName, is("Enterprise for AWS")); RecordedRequest recordedRequest = mWebMockRule.get().takeRequest(); assertThat("Should accept text plain header", recordedRequest, containsHeader("Accept", "text/plain; charset=UTF-8")); assertThat("Should have path '/rest_v2/serverInfo/build'", recordedRequest, hasPath("/rest_v2/serverInfo/build")); } |
### Question:
ServerRestApi { @NotNull public String requestDateFormatPattern() throws IOException, HttpException { return plainRequest("rest_v2/serverInfo/dateFormatPattern"); } ServerRestApi(NetworkClient networkClient); @NotNull ServerInfoData requestServerInfo(); @NotNull String requestBuild(); @NotNull String requestEdition(); @NotNull String requestVersion(); @NotNull String requestFeatures(); @NotNull String requestEditionName(); @NotNull String requestLicenseType(); @NotNull String requestExpiration(); @NotNull String requestDateFormatPattern(); @NotNull String requestDateTimeFormatPattern(); }### Answer:
@Test public void shouldHandlePlainTextResponseForDateFormatPattern() throws Exception { mWebMockRule.enqueue( MockResponseFactory.create200().setBody("yyyy-MM-dd") ); String editionName = objectUnderTest.requestDateFormatPattern(); assertThat(editionName, is("yyyy-MM-dd")); RecordedRequest recordedRequest = mWebMockRule.get().takeRequest(); assertThat("Should accept text plain header", recordedRequest, containsHeader("Accept", "text/plain; charset=UTF-8")); assertThat("Should have path '/rest_v2/serverInfo/dateFormatPattern'", recordedRequest, hasPath("/rest_v2/serverInfo/dateFormatPattern")); } |
### Question:
ServerRestApi { @NotNull public String requestDateTimeFormatPattern() throws IOException, HttpException { return plainRequest("rest_v2/serverInfo/datetimeFormatPattern"); } ServerRestApi(NetworkClient networkClient); @NotNull ServerInfoData requestServerInfo(); @NotNull String requestBuild(); @NotNull String requestEdition(); @NotNull String requestVersion(); @NotNull String requestFeatures(); @NotNull String requestEditionName(); @NotNull String requestLicenseType(); @NotNull String requestExpiration(); @NotNull String requestDateFormatPattern(); @NotNull String requestDateTimeFormatPattern(); }### Answer:
@Test public void shouldHandlePlainTextResponseForDatetimeFormatPattern() throws Exception { mWebMockRule.enqueue( MockResponseFactory.create200().setBody("yyyy-MM-dd'T'HH:mm:ss") ); String editionName = objectUnderTest.requestDateTimeFormatPattern(); assertThat(editionName, is("yyyy-MM-dd'T'HH:mm:ss")); RecordedRequest recordedRequest = mWebMockRule.get().takeRequest(); assertThat("Should accept text plain header", recordedRequest, containsHeader("Accept", "text/plain; charset=UTF-8")); assertThat("Should have path '/rest_v2/serverInfo/datetimeFormatPattern'", recordedRequest, hasPath("/rest_v2/serverInfo/datetimeFormatPattern")); } |
### Question:
ServerRestApi { @NotNull public String requestEdition() throws IOException, HttpException { return plainRequest("rest_v2/serverInfo/edition"); } ServerRestApi(NetworkClient networkClient); @NotNull ServerInfoData requestServerInfo(); @NotNull String requestBuild(); @NotNull String requestEdition(); @NotNull String requestVersion(); @NotNull String requestFeatures(); @NotNull String requestEditionName(); @NotNull String requestLicenseType(); @NotNull String requestExpiration(); @NotNull String requestDateFormatPattern(); @NotNull String requestDateTimeFormatPattern(); }### Answer:
@Test public void shouldHandlePlainTextResponseForEdition() throws Exception { mWebMockRule.enqueue( MockResponseFactory.create200().setBody("PRO") ); String editionName = objectUnderTest.requestEdition(); assertThat(editionName, is("PRO")); RecordedRequest recordedRequest = mWebMockRule.get().takeRequest(); assertThat("Should accept text plain header", recordedRequest, containsHeader("Accept", "text/plain; charset=UTF-8")); assertThat("Should have path '/rest_v2/serverInfo/edition'", recordedRequest, hasPath("/rest_v2/serverInfo/edition")); } |
### Question:
ServerRestApi { @NotNull public String requestEditionName() throws IOException, HttpException { return plainRequest("rest_v2/serverInfo/editionName"); } ServerRestApi(NetworkClient networkClient); @NotNull ServerInfoData requestServerInfo(); @NotNull String requestBuild(); @NotNull String requestEdition(); @NotNull String requestVersion(); @NotNull String requestFeatures(); @NotNull String requestEditionName(); @NotNull String requestLicenseType(); @NotNull String requestExpiration(); @NotNull String requestDateFormatPattern(); @NotNull String requestDateTimeFormatPattern(); }### Answer:
@Test public void shouldHandlePlainTextResponseForEditionName() throws Exception { mWebMockRule.enqueue( MockResponseFactory.create200().setBody("Enterprise for AWS") ); String editionName = objectUnderTest.requestEditionName(); assertThat(editionName, is("Enterprise for AWS")); RecordedRequest recordedRequest = mWebMockRule.get().takeRequest(); assertThat("Should accept text plain header", recordedRequest, containsHeader("Accept", "text/plain; charset=UTF-8")); assertThat("Should have path '/rest_v2/serverInfo/editionName'", recordedRequest, hasPath("/rest_v2/serverInfo/editionName")); } |
### Question:
ServerRestApi { @NotNull public String requestExpiration() throws IOException, HttpException { return plainRequest("rest_v2/serverInfo/expiration"); } ServerRestApi(NetworkClient networkClient); @NotNull ServerInfoData requestServerInfo(); @NotNull String requestBuild(); @NotNull String requestEdition(); @NotNull String requestVersion(); @NotNull String requestFeatures(); @NotNull String requestEditionName(); @NotNull String requestLicenseType(); @NotNull String requestExpiration(); @NotNull String requestDateFormatPattern(); @NotNull String requestDateTimeFormatPattern(); }### Answer:
@Test public void shouldHandlePlainTextResponseForExpiration() throws Exception { mWebMockRule.enqueue( MockResponseFactory.create200().setBody("1000") ); String editionName = objectUnderTest.requestExpiration(); assertThat(editionName, is("1000")); RecordedRequest recordedRequest = mWebMockRule.get().takeRequest(); assertThat("Should accept text plain header", recordedRequest, containsHeader("Accept", "text/plain; charset=UTF-8")); assertThat("Should have path '/rest_v2/serverInfo/expiration'", recordedRequest, hasPath("/rest_v2/serverInfo/expiration")); } |
### Question:
ServerRestApi { @NotNull public String requestFeatures() throws IOException, HttpException { return plainRequest("rest_v2/serverInfo/features"); } ServerRestApi(NetworkClient networkClient); @NotNull ServerInfoData requestServerInfo(); @NotNull String requestBuild(); @NotNull String requestEdition(); @NotNull String requestVersion(); @NotNull String requestFeatures(); @NotNull String requestEditionName(); @NotNull String requestLicenseType(); @NotNull String requestExpiration(); @NotNull String requestDateFormatPattern(); @NotNull String requestDateTimeFormatPattern(); }### Answer:
@Test public void shouldHandlePlainTextResponseForFeatures() throws Exception { mWebMockRule.enqueue( MockResponseFactory.create200().setBody("Fusion AHD EXP DB ANA AUD MT ") ); String editionName = objectUnderTest.requestFeatures(); assertThat(editionName, is("Fusion AHD EXP DB ANA AUD MT ")); RecordedRequest recordedRequest = mWebMockRule.get().takeRequest(); assertThat("Should accept text plain header", recordedRequest, containsHeader("Accept", "text/plain; charset=UTF-8")); assertThat("Should have path '/rest_v2/serverInfo/features'", recordedRequest, hasPath("/rest_v2/serverInfo/features")); } |
### Question:
ServerRestApi { @NotNull public String requestLicenseType() throws IOException, HttpException { return plainRequest("rest_v2/serverInfo/licenseType"); } ServerRestApi(NetworkClient networkClient); @NotNull ServerInfoData requestServerInfo(); @NotNull String requestBuild(); @NotNull String requestEdition(); @NotNull String requestVersion(); @NotNull String requestFeatures(); @NotNull String requestEditionName(); @NotNull String requestLicenseType(); @NotNull String requestExpiration(); @NotNull String requestDateFormatPattern(); @NotNull String requestDateTimeFormatPattern(); }### Answer:
@Test public void shouldHandlePlainTextResponseForLicenseType() throws Exception { mWebMockRule.enqueue( MockResponseFactory.create200().setBody("Commercial") ); String editionName = objectUnderTest.requestLicenseType(); assertThat(editionName, is("Commercial")); RecordedRequest recordedRequest = mWebMockRule.get().takeRequest(); assertThat("Should accept text plain header", recordedRequest, containsHeader("Accept", "text/plain; charset=UTF-8")); assertThat("Should have path '/rest_v2/serverInfo/licenseType'", recordedRequest, hasPath("/rest_v2/serverInfo/licenseType")); } |
### Question:
ServerRestApi { @NotNull public String requestVersion() throws IOException, HttpException { return plainRequest("rest_v2/serverInfo/version"); } ServerRestApi(NetworkClient networkClient); @NotNull ServerInfoData requestServerInfo(); @NotNull String requestBuild(); @NotNull String requestEdition(); @NotNull String requestVersion(); @NotNull String requestFeatures(); @NotNull String requestEditionName(); @NotNull String requestLicenseType(); @NotNull String requestExpiration(); @NotNull String requestDateFormatPattern(); @NotNull String requestDateTimeFormatPattern(); }### Answer:
@Test public void shouldHandlePlainTextResponseFor() throws Exception { mWebMockRule.enqueue( MockResponseFactory.create200().setBody("5.5.0") ); String editionName = objectUnderTest.requestVersion(); assertThat(editionName, is("5.5.0")); RecordedRequest recordedRequest = mWebMockRule.get().takeRequest(); assertThat("Should accept text plain header", recordedRequest, containsHeader("Accept", "text/plain; charset=UTF-8")); assertThat("Should have path '/rest_v2/serverInfo/version'", recordedRequest, hasPath("/rest_v2/serverInfo/version")); } |
### Question:
ReportExecutionRestApi { @NotNull public ReportExecutionDescriptor requestReportExecutionDetails(@NotNull String executionId) throws IOException, HttpException { Utils.checkNotNull(executionId, "Execution id should not be null"); HttpUrl url = mNetworkClient.getBaseUrl().resolve("rest_v2/reportExecutions") .newBuilder() .addPathSegment(executionId) .build(); Request request = new Request.Builder() .addHeader("Accept", "application/json; charset=UTF-8") .get() .url(url) .build(); com.squareup.okhttp.Response response = mNetworkClient.makeCall(request); return mNetworkClient.deserializeJson(response, ReportExecutionDescriptor.class); } ReportExecutionRestApi(NetworkClient networkClient); @NotNull ReportExecutionDescriptor runReportExecution(@NotNull ReportExecutionRequestOptions executionOptions); @NotNull ReportExecutionDescriptor requestReportExecutionDetails(@NotNull String executionId); @NotNull ExecutionStatus requestReportExecutionStatus(@NotNull String executionId); boolean cancelReportExecution(@NotNull String executionId); boolean updateReportExecution(@NotNull String executionId,
@NotNull List<ReportParameter> params); }### Answer:
@Test public void executionIdShouldNotBeNullForRequestExecutionDetails() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Execution id should not be null"); restApiUnderTest.requestReportExecutionDetails(null); }
@Test public void shouldRequestReportExecutionDetails() throws Exception { MockResponse response = MockResponseFactory.create200().setBody(reportExecutionDetailsResponse.asString()); mWebMockRule.enqueue(response); ReportExecutionDescriptor details = restApiUnderTest.requestReportExecutionDetails(EXEC_ID); assertThat(details, is(notNullValue())); RecordedRequest request = mWebMockRule.get().takeRequest(); assertThat(request, containsHeader("Accept", "application/json; charset=UTF-8")); assertThat(request, hasPath("/rest_v2/reportExecutions/f3a9805a-4089-4b53-b9e9-b54752f91586")); assertThat(request, wasMethod("GET")); } |
### Question:
ReportExecutionRestApi { @NotNull public ExecutionStatus requestReportExecutionStatus(@NotNull String executionId) throws IOException, HttpException { Utils.checkNotNull(executionId, "Execution id should not be null"); HttpUrl url = mNetworkClient.getBaseUrl() .resolve("rest_v2/reportExecutions") .newBuilder() .addPathSegment(executionId) .addPathSegment("status") .build(); Request request = new Request.Builder() .addHeader("Accept", "application/json; charset=UTF-8") .get() .url(url) .build(); com.squareup.okhttp.Response response = mNetworkClient.makeCall(request); return mNetworkClient.deserializeJson(response, ExecutionStatus.class); } ReportExecutionRestApi(NetworkClient networkClient); @NotNull ReportExecutionDescriptor runReportExecution(@NotNull ReportExecutionRequestOptions executionOptions); @NotNull ReportExecutionDescriptor requestReportExecutionDetails(@NotNull String executionId); @NotNull ExecutionStatus requestReportExecutionStatus(@NotNull String executionId); boolean cancelReportExecution(@NotNull String executionId); boolean updateReportExecution(@NotNull String executionId,
@NotNull List<ReportParameter> params); }### Answer:
@Test public void executionIdShouldNotBeNullForRequestExecutionStatus() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Execution id should not be null"); restApiUnderTest.requestReportExecutionStatus(null); }
@Test public void shouldRequestReportExecutionStatus() throws Exception { MockResponse response = MockResponseFactory.create200().setBody("{\"value\":\"execution\"}"); mWebMockRule.enqueue(response); ExecutionStatus status = restApiUnderTest.requestReportExecutionStatus(EXEC_ID); assertThat(status, is(notNullValue())); RecordedRequest request = mWebMockRule.get().takeRequest(); assertThat(request, containsHeader("Accept", "application/json; charset=UTF-8")); assertThat(request, hasPath("/rest_v2/reportExecutions/f3a9805a-4089-4b53-b9e9-b54752f91586/status")); assertThat(request, wasMethod("GET")); } |
### Question:
RetrofitOutputResource implements OutputResource { @Override public String getMimeType() { return mResponse.contentType().type(); } RetrofitOutputResource(ResponseBody input); @Override String getMimeType(); @Override long getLength(); @Override InputStream getStream(); }### Answer:
@Test public void shouldDelegateMimeType() { when(mTypedInput.contentType()).thenReturn(MediaType.parse("multipart/form-data")); objectUnderTest.getMimeType(); verify(mTypedInput, times(1)).contentType(); } |
### Question:
RetrofitOutputResource implements OutputResource { @Override public long getLength() { try { return mResponse.contentLength(); } catch (IOException e) { return -1; } } RetrofitOutputResource(ResponseBody input); @Override String getMimeType(); @Override long getLength(); @Override InputStream getStream(); }### Answer:
@Test public void shouldDelegateLength() throws IOException { objectUnderTest.getLength(); verify(mTypedInput, times(1)).contentLength(); } |
### Question:
RetrofitOutputResource implements OutputResource { @Override public InputStream getStream() throws IOException { return mResponse.byteStream(); } RetrofitOutputResource(ResponseBody input); @Override String getMimeType(); @Override long getLength(); @Override InputStream getStream(); }### Answer:
@Test public void shouldDelegateInputStream() throws IOException { when(mTypedInput.byteStream()).thenReturn(input); objectUnderTest.getStream(); verify(mTypedInput, times(1)).byteStream(); } |
### Question:
KeyUtils { public static KeyPair rsaKeyPairFromBase64(String publicKey, String privateKey) throws GeneralSecurityException { try { byte[] pubKeyBytes = Base64.decodeBase64(publicKey.getBytes("US-ASCII")); byte[] privKeyBytes = Base64.decodeBase64(privateKey.getBytes("US-ASCII")); X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(pubKeyBytes); PKCS8EncodedKeySpec privKeySpec = new PKCS8EncodedKeySpec(privKeyBytes); PublicKey pubKey; PrivateKey privKey; KeyFactory keyFactory = KeyFactory.getInstance("RSA"); pubKey = keyFactory.generatePublic(pubKeySpec); privKey = keyFactory.generatePrivate(privKeySpec); return new KeyPair(pubKey, privKey); } catch (UnsupportedEncodingException e) { throw new RuntimeException("Could not load key pair: " + e, e); } } static String getRsaPublicKeyFingerprint(RSAPublicKey pubKey, Provider provider); static String toHexPadded(byte[] data); static byte[] derEncodeBigInteger(BigInteger value); static byte[] derEncodeValue(byte type, byte[] bytes); static byte[] derEncodeRSAPublicKey(RSAPublicKey pubkey); static byte[] derEncodeSequence(List<byte[]> objects); static KeyPair rsaKeyPairFromBase64(String publicKey, String privateKey); static SecretKey decryptKey(String encodedKey, String algorithm, Provider provider, PrivateKey privateKey); static String encryptKey(SecretKey key, Provider provider, PublicKey publicKey); static String urlSafeEncodeBase64(byte[] data); static byte[] urlSafeDecodeBase64(String b64Data); static String signMetadata(Map<String, String> metadata,
RSAPrivateKey privateKey, Provider provider); static byte[] extractSubjectKeyIdentifier(byte[] derSki); }### Answer:
@Test(expected=GeneralSecurityException.class) public void testDecodeBadKey() throws Exception { KeyUtils.rsaKeyPairFromBase64("aaaAAAaa", "bbBBBBbbb"); } |
### Question:
BasicEncryptionTransformFactory extends
EncryptionTransformFactory<BasicEncryptionOutputTransform, BasicEncryptionInputTransform> { public void addMasterDecryptionKey(KeyPair pair) { try { String fingerprint = KeyUtils .getRsaPublicKeyFingerprint((RSAPublicKey) pair.getPublic(), provider); masterDecryptionKeys.put(fingerprint, pair); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("Error adding master key", e); } } BasicEncryptionTransformFactory(); BasicEncryptionTransformFactory(KeyPair masterEncryptionKey,
Set<KeyPair> masterDecryptionKeys); BasicEncryptionTransformFactory(KeyPair masterEncryptionKey,
Set<KeyPair> masterDecryptionKeys, Provider provider); void setMasterEncryptionKey(KeyPair pair); void addMasterDecryptionKey(KeyPair pair); @Override Map<String, String> rekey(Map<String, String> metadata); @Override BasicEncryptionOutputTransform getOutputTransform(
OutputStream streamToEncodeTo, Map<String, String> metadataToEncode); @Override BasicEncryptionOutputTransform getOutputTransform(
InputStream streamToEncode, Map<String, String> metadataToEncode); @Override BasicEncryptionInputTransform getInputTransform(
String transformConfig, InputStream streamToDecode,
Map<String, String> metadata); public KeyPair masterEncryptionKey; }### Answer:
@Test public void testAddMasterDecryptionKey() throws Exception { BasicEncryptionTransformFactory factory = new BasicEncryptionTransformFactory(); factory.setCryptoProvider(provider); factory.setMasterEncryptionKey(masterKey); factory.addMasterDecryptionKey(oldKey); } |
### Question:
CompressionTransformFactory extends
TransformFactory<CompressionOutputTransform, CompressionInputTransform> { @Override public String getTransformClass() { return TransformConstants.COMPRESSION_CLASS; } CompressionTransformFactory(); CompressionMode getCompressMode(); void setCompressMode(CompressionMode compressMode); int getCompressionLevel(); void setCompressionLevel(int compressionLevel); @Override CompressionOutputTransform getOutputTransform(
OutputStream streamToEncodeTo, Map<String, String> metadataToEncode); @Override CompressionOutputTransform getOutputTransform(
InputStream streamToEncode, Map<String, String> metadataToEncode); @Override CompressionInputTransform getInputTransform(String transformConfig, InputStream streamToDecode, Map<String, String> metadata); @Override String getTransformClass(); boolean canDecode(String transformClass, String config, Map<String,String> metadata); static long memoryRequiredForLzma(int compressionLevel); static long memoryRequiredForLzma(LzmaProfile profile); public CompressionMode compressMode; public int compressionLevel; static LzmaProfile LZMA_COMPRESSION_PROFILE; }### Answer:
@Test public void testGetTransformClass() { CompressionTransformFactory factory = new CompressionTransformFactory(); assertEquals(TransformConstants.COMPRESSION_CLASS, factory.getTransformClass()); } |
### Question:
CompressionTransformFactory extends
TransformFactory<CompressionOutputTransform, CompressionInputTransform> { public CompressionMode getCompressMode() { return compressMode; } CompressionTransformFactory(); CompressionMode getCompressMode(); void setCompressMode(CompressionMode compressMode); int getCompressionLevel(); void setCompressionLevel(int compressionLevel); @Override CompressionOutputTransform getOutputTransform(
OutputStream streamToEncodeTo, Map<String, String> metadataToEncode); @Override CompressionOutputTransform getOutputTransform(
InputStream streamToEncode, Map<String, String> metadataToEncode); @Override CompressionInputTransform getInputTransform(String transformConfig, InputStream streamToDecode, Map<String, String> metadata); @Override String getTransformClass(); boolean canDecode(String transformClass, String config, Map<String,String> metadata); static long memoryRequiredForLzma(int compressionLevel); static long memoryRequiredForLzma(LzmaProfile profile); public CompressionMode compressMode; public int compressionLevel; static LzmaProfile LZMA_COMPRESSION_PROFILE; }### Answer:
@Test public void testGetCompressMode() { CompressionTransformFactory factory = new CompressionTransformFactory(); assertEquals("default mode incorrect", CompressionMode.Deflate, factory.getCompressMode()); } |
### Question:
ViPRResponsesSaxParser extends XmlResponsesSaxParser { public ListDataNodesResultHandler parseListDataNodeResult(InputStream inputStream) throws AmazonClientException { ListDataNodesResultHandler handler = new ListDataNodesResultHandler(); parseXmlInputStream(handler, inputStream); return handler; } FileAccessResultHandler parseFileAccessResult(InputStream inputStream); ListDataNodesResultHandler parseListDataNodeResult(InputStream inputStream); }### Answer:
@Test public void testDataNodesResult() throws Exception { String rawXml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n" + " <ListDataNode xmlns=\"http: " <DataNodes> 10.247.102.239</DataNodes>\n" + " <DataNodes>10.247.102.240</DataNodes>\n" + " <DataNodes>10.247.102.241 </DataNodes>\n" + " <VersionInfo>vipr-2.0.0.0.r2b3e482</VersionInfo>\n" + " </ListDataNode>"; ListDataNodesResult result = new ViPRResponsesSaxParser().parseListDataNodeResult(new StringInputStream(rawXml)).getResult(); Assert.assertNotNull("result is null", result); Assert.assertEquals("wrong version", "vipr-2.0.0.0.r2b3e482", result.getVersion()); Assert.assertEquals("wrong number of hosts", 3, result.getHosts().size()); Assert.assertEquals("wrong 1st host", "10.247.102.239", result.getHosts().get(0)); Assert.assertEquals("wrong 2nd host", "10.247.102.240", result.getHosts().get(1)); Assert.assertEquals("wrong 3rd host", "10.247.102.241", result.getHosts().get(2)); } |
### Question:
CompressionTransformFactory extends
TransformFactory<CompressionOutputTransform, CompressionInputTransform> { public void setCompressMode(CompressionMode compressMode) { this.compressMode = compressMode; } CompressionTransformFactory(); CompressionMode getCompressMode(); void setCompressMode(CompressionMode compressMode); int getCompressionLevel(); void setCompressionLevel(int compressionLevel); @Override CompressionOutputTransform getOutputTransform(
OutputStream streamToEncodeTo, Map<String, String> metadataToEncode); @Override CompressionOutputTransform getOutputTransform(
InputStream streamToEncode, Map<String, String> metadataToEncode); @Override CompressionInputTransform getInputTransform(String transformConfig, InputStream streamToDecode, Map<String, String> metadata); @Override String getTransformClass(); boolean canDecode(String transformClass, String config, Map<String,String> metadata); static long memoryRequiredForLzma(int compressionLevel); static long memoryRequiredForLzma(LzmaProfile profile); public CompressionMode compressMode; public int compressionLevel; static LzmaProfile LZMA_COMPRESSION_PROFILE; }### Answer:
@Test public void testSetCompressMode() { CompressionTransformFactory factory = new CompressionTransformFactory(); factory.setCompressMode(CompressionMode.LZMA); assertEquals("mode incorrect", CompressionMode.LZMA, factory.getCompressMode()); } |
### Question:
CompressionTransformFactory extends
TransformFactory<CompressionOutputTransform, CompressionInputTransform> { public int getCompressionLevel() { return compressionLevel; } CompressionTransformFactory(); CompressionMode getCompressMode(); void setCompressMode(CompressionMode compressMode); int getCompressionLevel(); void setCompressionLevel(int compressionLevel); @Override CompressionOutputTransform getOutputTransform(
OutputStream streamToEncodeTo, Map<String, String> metadataToEncode); @Override CompressionOutputTransform getOutputTransform(
InputStream streamToEncode, Map<String, String> metadataToEncode); @Override CompressionInputTransform getInputTransform(String transformConfig, InputStream streamToDecode, Map<String, String> metadata); @Override String getTransformClass(); boolean canDecode(String transformClass, String config, Map<String,String> metadata); static long memoryRequiredForLzma(int compressionLevel); static long memoryRequiredForLzma(LzmaProfile profile); public CompressionMode compressMode; public int compressionLevel; static LzmaProfile LZMA_COMPRESSION_PROFILE; }### Answer:
@Test public void testGetCompressionLevel() { CompressionTransformFactory factory = new CompressionTransformFactory(); assertEquals("Default compression level incorrect", 5, factory.getCompressionLevel()); } |
### Question:
CompressionTransformFactory extends
TransformFactory<CompressionOutputTransform, CompressionInputTransform> { public void setCompressionLevel(int compressionLevel) { this.compressionLevel = compressionLevel; } CompressionTransformFactory(); CompressionMode getCompressMode(); void setCompressMode(CompressionMode compressMode); int getCompressionLevel(); void setCompressionLevel(int compressionLevel); @Override CompressionOutputTransform getOutputTransform(
OutputStream streamToEncodeTo, Map<String, String> metadataToEncode); @Override CompressionOutputTransform getOutputTransform(
InputStream streamToEncode, Map<String, String> metadataToEncode); @Override CompressionInputTransform getInputTransform(String transformConfig, InputStream streamToDecode, Map<String, String> metadata); @Override String getTransformClass(); boolean canDecode(String transformClass, String config, Map<String,String> metadata); static long memoryRequiredForLzma(int compressionLevel); static long memoryRequiredForLzma(LzmaProfile profile); public CompressionMode compressMode; public int compressionLevel; static LzmaProfile LZMA_COMPRESSION_PROFILE; }### Answer:
@Test public void testSetCompressionLevel() { CompressionTransformFactory factory = new CompressionTransformFactory(); for(int i=0; i<10; i++) { factory.setCompressionLevel(i); assertEquals("Compression level did not set correctly", i, factory.getCompressionLevel()); } checkInvalidCompression(factory, CompressionMode.Deflate, -1); checkInvalidCompression(factory, CompressionMode.LZMA, -1); checkInvalidCompression(factory, CompressionMode.Deflate, 10); checkInvalidCompression(factory, CompressionMode.LZMA, 10); } |
### Question:
CompressionTransformFactory extends
TransformFactory<CompressionOutputTransform, CompressionInputTransform> { @Override public CompressionOutputTransform getOutputTransform( OutputStream streamToEncodeTo, Map<String, String> metadataToEncode) throws IOException { switch(compressMode) { case Deflate: return new DeflateOutputTransform(streamToEncodeTo, metadataToEncode, compressionLevel); case LZMA: return new LZMAOutputTransform(streamToEncodeTo, metadataToEncode, compressionLevel); default: throw new IllegalArgumentException("Unsupported compression method " + compressMode); } } CompressionTransformFactory(); CompressionMode getCompressMode(); void setCompressMode(CompressionMode compressMode); int getCompressionLevel(); void setCompressionLevel(int compressionLevel); @Override CompressionOutputTransform getOutputTransform(
OutputStream streamToEncodeTo, Map<String, String> metadataToEncode); @Override CompressionOutputTransform getOutputTransform(
InputStream streamToEncode, Map<String, String> metadataToEncode); @Override CompressionInputTransform getInputTransform(String transformConfig, InputStream streamToDecode, Map<String, String> metadata); @Override String getTransformClass(); boolean canDecode(String transformClass, String config, Map<String,String> metadata); static long memoryRequiredForLzma(int compressionLevel); static long memoryRequiredForLzma(LzmaProfile profile); public CompressionMode compressMode; public int compressionLevel; static LzmaProfile LZMA_COMPRESSION_PROFILE; }### Answer:
@Test public void testGetOutputTransform() throws IOException { CompressionTransformFactory factory = new CompressionTransformFactory(); CompressionOutputTransform t = factory.getOutputTransform(new ByteArrayOutputStream(), new HashMap<String, String>()); assertNotNull("output transform null", t); } |
### Question:
LZMAInputStream extends InputStream implements Runnable { @Override public int read() throws IOException { checkStream(); try { return uncompressedPipeIn.read(); } catch(IOException e) { if(getDecompressionComplete()) { return -1; } throw e; } } LZMAInputStream(InputStream compressedStream); LZMAInputStream(InputStream compressedStream, int bufferSize); @Override int read(); @Override int available(); @Override void close(); @Override boolean markSupported(); @Override int read(byte[] b, int off, int len); @Override int read(byte[] b); @Override long skip(long n); @Override void run(); }### Answer:
@Test public void testRead() throws Exception { InputStream decompressed = new LZMAInputStream(compressedData); int in1, in2; long offset = 0; while((in1 = uncompressedData.read()) != -1) { in2 = decompressed.read(); assertEquals("Mismatch at offset " + offset, in1, in2); offset++; } in2 = decompressed.read(); assertEquals("Mismatch at EOF", -1, in2); decompressed.close(); uncompressedData.close(); } |
### Question:
LZMAInputStream extends InputStream implements Runnable { @Override public long skip(long n) throws IOException { checkStream(); try { return uncompressedPipeIn.skip(n); } catch(IOException e) { if(getDecompressionComplete()) { return -1; } throw e; } } LZMAInputStream(InputStream compressedStream); LZMAInputStream(InputStream compressedStream, int bufferSize); @Override int read(); @Override int available(); @Override void close(); @Override boolean markSupported(); @Override int read(byte[] b, int off, int len); @Override int read(byte[] b); @Override long skip(long n); @Override void run(); }### Answer:
@Test public void testSkip() throws Exception { InputStream decompressed = new LZMAInputStream(compressedData); int in1, in2; long offset = 0; while((in1 = uncompressedData.read()) != -1) { in2 = decompressed.read(); assertEquals("Mismatch at offset " + offset, in1, in2); long offset1 = uncompressedData.skip(7); long offset2 = decompressed.skip(7); assertEquals("Skipped bytes mismatch at offset " + offset, offset1, offset2); offset += offset1 + 1; } in2 = decompressed.read(); assertEquals("Mismatch at EOF", -1, in2); decompressed.close(); uncompressedData.close(); } |
### Question:
LZMAInputStream extends InputStream implements Runnable { @Override public boolean markSupported() { return false; } LZMAInputStream(InputStream compressedStream); LZMAInputStream(InputStream compressedStream, int bufferSize); @Override int read(); @Override int available(); @Override void close(); @Override boolean markSupported(); @Override int read(byte[] b, int off, int len); @Override int read(byte[] b); @Override long skip(long n); @Override void run(); }### Answer:
@Test public void testMarkSupported() throws Exception { InputStream decompressed = new LZMAInputStream(compressedData); assertFalse(decompressed.markSupported()); decompressed.close(); } |
### Question:
DeflateOutputStream extends OutputStream implements CompressionStream { @Override public void write(int b) throws IOException { digester.write(b); } DeflateOutputStream(OutputStream streamToCompress, int level); @Override Map<String, String> getStreamMetadata(); @Override void write(int b); @Override void close(); @Override void flush(); @Override void write(byte[] b, int off, int len); @Override void write(byte[] b); }### Answer:
@Test public void testWrite() throws Exception { ByteArrayOutputStream compressedData = new ByteArrayOutputStream(); DeflateOutputStream out = new DeflateOutputStream(compressedData, 5); out.write(data); try { out.getStreamMetadata(); fail("Should have thrown IllegalStateException that stream was not closed yet."); } catch(IllegalStateException e) { } out.close(); Map<String, String> m = out.getStreamMetadata(); assertEquals("Uncompressed digest incorrect", "027e997e6b1dfc97b93eb28dc9a6804096d85873", m.get(TransformConstants.META_COMPRESSION_UNCOMP_SHA1)); assertEquals("Compression ratio incorrect", "91.1%", m.get(TransformConstants.META_COMPRESSION_COMP_RATIO)); assertEquals("Uncompressed size incorrect", 2516125, Long.parseLong(m .get(TransformConstants.META_COMPRESSION_UNCOMP_SIZE))); assertEquals("Compressed size incorrect", 223548, Long.parseLong(m .get(TransformConstants.META_COMPRESSION_COMP_SIZE))); } |
### Question:
KeyStoreEncryptionFactory extends
EncryptionTransformFactory<BasicEncryptionOutputTransform, BasicEncryptionInputTransform> { public KeyStoreEncryptionFactory(KeyStore keyStore, String masterEncryptionKeyAlias, char[] keyStorePassword) throws InvalidKeyException, NoSuchAlgorithmException, NoSuchPaddingException, TransformException { this(keyStore, masterEncryptionKeyAlias, keyStorePassword, null); } KeyStoreEncryptionFactory(KeyStore keyStore,
String masterEncryptionKeyAlias,
char[] keyStorePassword); KeyStoreEncryptionFactory(KeyStore keyStore,
String masterEncryptionKeyAlias, char[] masterKeyPassword, Provider provider); @Override Map<String, String> rekey(Map<String, String> metadata); @Override BasicEncryptionOutputTransform getOutputTransform(
OutputStream streamToEncodeTo, Map<String, String> metadataToEncode); @Override BasicEncryptionOutputTransform getOutputTransform(
InputStream streamToEncode, Map<String, String> metadataToEncode); @Override BasicEncryptionInputTransform getInputTransform(
String transformConfig, InputStream streamToDecode,
Map<String, String> metadata); String getMasterEncryptionKeyAlias(); void setMasterEncryptionKeyAlias(String alias); }### Answer:
@Test public void testKeyStoreEncryptionFactory() throws Exception { try { new KeyStoreEncryptionFactory(keystore, "NoKey", keystorePassword.toCharArray(), provider); fail("Should not init with invalid key alias"); } catch(InvalidKeyException e) { } } |
### Question:
KeyStoreEncryptionFactory extends
EncryptionTransformFactory<BasicEncryptionOutputTransform, BasicEncryptionInputTransform> { public String getMasterEncryptionKeyAlias() { return masterEncryptionKeyAlias; } KeyStoreEncryptionFactory(KeyStore keyStore,
String masterEncryptionKeyAlias,
char[] keyStorePassword); KeyStoreEncryptionFactory(KeyStore keyStore,
String masterEncryptionKeyAlias, char[] masterKeyPassword, Provider provider); @Override Map<String, String> rekey(Map<String, String> metadata); @Override BasicEncryptionOutputTransform getOutputTransform(
OutputStream streamToEncodeTo, Map<String, String> metadataToEncode); @Override BasicEncryptionOutputTransform getOutputTransform(
InputStream streamToEncode, Map<String, String> metadataToEncode); @Override BasicEncryptionInputTransform getInputTransform(
String transformConfig, InputStream streamToDecode,
Map<String, String> metadata); String getMasterEncryptionKeyAlias(); void setMasterEncryptionKeyAlias(String alias); }### Answer:
@Test public void testGetInputTransformNoCertSKI() throws Exception { KeyStoreEncryptionFactory factory = new KeyStoreEncryptionFactory(keystore, "masterkey2", keystorePassword.toCharArray(), provider); assertEquals("Wrong master key", "masterkey2", factory.getMasterEncryptionKeyAlias()); } |
### Question:
KeyUtils { public static String getRsaPublicKeyFingerprint(RSAPublicKey pubKey, Provider provider) throws NoSuchAlgorithmException { byte[] pubkeyEnc = derEncodeRSAPublicKey(pubKey); MessageDigest sha1; if(provider != null) { sha1 = MessageDigest.getInstance("sha1", provider); } else { sha1 = MessageDigest.getInstance("sha1"); } byte[] pubkeyDigest = sha1.digest(pubkeyEnc); return toHexPadded(pubkeyDigest); } static String getRsaPublicKeyFingerprint(RSAPublicKey pubKey, Provider provider); static String toHexPadded(byte[] data); static byte[] derEncodeBigInteger(BigInteger value); static byte[] derEncodeValue(byte type, byte[] bytes); static byte[] derEncodeRSAPublicKey(RSAPublicKey pubkey); static byte[] derEncodeSequence(List<byte[]> objects); static KeyPair rsaKeyPairFromBase64(String publicKey, String privateKey); static SecretKey decryptKey(String encodedKey, String algorithm, Provider provider, PrivateKey privateKey); static String encryptKey(SecretKey key, Provider provider, PublicKey publicKey); static String urlSafeEncodeBase64(byte[] data); static byte[] urlSafeDecodeBase64(String b64Data); static String signMetadata(Map<String, String> metadata,
RSAPrivateKey privateKey, Provider provider); static byte[] extractSubjectKeyIdentifier(byte[] derSki); }### Answer:
@Test public void testGetRsaPublicKeyFingerprint() throws NoSuchAlgorithmException { assertEquals("Key fingerprint invalid", "000317457b5645b7b5c4daf4cf6780c05438effd", KeyUtils.getRsaPublicKeyFingerprint((RSAPublicKey) masterKey .getPublic(), provider)); } |
### Question:
KeyUtils { public static String toHexPadded(byte[] data) { BigInteger bi = new BigInteger(1, data); String s = bi.toString(16); while(s.length() < (data.length*2)) { s = "0" + s; } return s; } static String getRsaPublicKeyFingerprint(RSAPublicKey pubKey, Provider provider); static String toHexPadded(byte[] data); static byte[] derEncodeBigInteger(BigInteger value); static byte[] derEncodeValue(byte type, byte[] bytes); static byte[] derEncodeRSAPublicKey(RSAPublicKey pubkey); static byte[] derEncodeSequence(List<byte[]> objects); static KeyPair rsaKeyPairFromBase64(String publicKey, String privateKey); static SecretKey decryptKey(String encodedKey, String algorithm, Provider provider, PrivateKey privateKey); static String encryptKey(SecretKey key, Provider provider, PublicKey publicKey); static String urlSafeEncodeBase64(byte[] data); static byte[] urlSafeDecodeBase64(String b64Data); static String signMetadata(Map<String, String> metadata,
RSAPrivateKey privateKey, Provider provider); static byte[] extractSubjectKeyIdentifier(byte[] derSki); }### Answer:
@Test public void testToHexPadded() { byte[] dataWithoutZeroes = new byte[] { 0x11, 0x22, 0x33 }; assertEquals("Without zeroes incorrect", "112233", KeyUtils.toHexPadded(dataWithoutZeroes)); byte[] dataWithLeadingZero = new byte[] { 0x01, 0x22, 0x33 }; assertEquals("With leading zero incorrect", "012233", KeyUtils.toHexPadded(dataWithLeadingZero)); byte[] dataWithLeadingZeroBytes = new byte[] { 0x00, 0x00, 0x11, 0x22, 0x33 }; assertEquals("Data with leading zero bytes incorrect", "0000112233", KeyUtils.toHexPadded(dataWithLeadingZeroBytes)); } |
### Question:
KeyUtils { public static byte[] extractSubjectKeyIdentifier(byte[] derSki) { byte[] dst = new byte[20]; if(derSki.length != 24) { throw new RuntimeException("DER-encoded SKI should be 24 bytes"); } System.arraycopy(derSki, 4, dst, 0, 20); return dst; } static String getRsaPublicKeyFingerprint(RSAPublicKey pubKey, Provider provider); static String toHexPadded(byte[] data); static byte[] derEncodeBigInteger(BigInteger value); static byte[] derEncodeValue(byte type, byte[] bytes); static byte[] derEncodeRSAPublicKey(RSAPublicKey pubkey); static byte[] derEncodeSequence(List<byte[]> objects); static KeyPair rsaKeyPairFromBase64(String publicKey, String privateKey); static SecretKey decryptKey(String encodedKey, String algorithm, Provider provider, PrivateKey privateKey); static String encryptKey(SecretKey key, Provider provider, PublicKey publicKey); static String urlSafeEncodeBase64(byte[] data); static byte[] urlSafeDecodeBase64(String b64Data); static String signMetadata(Map<String, String> metadata,
RSAPrivateKey privateKey, Provider provider); static byte[] extractSubjectKeyIdentifier(byte[] derSki); }### Answer:
@Test(expected=RuntimeException.class) public void testBadSki() { KeyUtils.extractSubjectKeyIdentifier(new byte[5]); } |
### Question:
PrimitiveUtils { public static Object getEmptyValue(Class<?> type) { return primitiveTypes.get(type).emptyValue; } private PrimitiveUtils(); static Object getEmptyValue(Class<?> type); static Class<?> getWrapperType(Class<?> type); static boolean isPrimitiveWrapper(Class<?> type); static String getPrimitiveTypeNameFromWrapper(Class<?> type); }### Answer:
@Test public void getEmptyValue() { assertNull(PrimitiveUtils.getEmptyValue(Void.TYPE)); assertEquals(false, PrimitiveUtils.getEmptyValue(Boolean.TYPE)); assertEquals((byte) 0, PrimitiveUtils.getEmptyValue(Byte.TYPE)); assertEquals((short) 0, PrimitiveUtils.getEmptyValue(Short.TYPE)); assertEquals((char) 0, PrimitiveUtils.getEmptyValue(Character.TYPE)); assertEquals(0, PrimitiveUtils.getEmptyValue(Integer.TYPE)); assertEquals(0L, PrimitiveUtils.getEmptyValue(Long.TYPE)); assertEquals((float) 0, PrimitiveUtils.getEmptyValue(Float.TYPE)); assertEquals((double) 0, PrimitiveUtils.getEmptyValue(Double.TYPE)); } |
### Question:
LinkedClassLoader extends ClassLoader { @Override protected Class<?> findClass(String name) throws ClassNotFoundException { Class<?> clazz = null; for (ClassLoader classLoader : classLoaders) { try { clazz = classLoader.loadClass(name); } catch (ClassNotFoundException e) { } } if (clazz == null) { throw new ClassNotFoundException(name); } return clazz; } LinkedClassLoader(ClassLoader... classLoaders); }### Answer:
@Test public void findClass() throws Exception { OneClassLoader stringLoader = new OneClassLoader(String.class.getName(), getClass().getClassLoader()); OneClassLoader testLoader = new OneClassLoader(getClass().getName(), getClass().getClassLoader()); LinkedClassLoader classLoader = new LinkedClassLoader(stringLoader, testLoader); assertSame(String.class, classLoader.findClass(String.class.getName())); assertSame(getClass(), classLoader.findClass(getClass().getName())); assertThrows(ClassNotFoundException.class, () -> classLoader.findClass(Test.class.getName())); } |
### Question:
PrimitiveUtils { public static Class<?> getWrapperType(Class<?> type) { return primitiveTypes.get(type).wrapperType; } private PrimitiveUtils(); static Object getEmptyValue(Class<?> type); static Class<?> getWrapperType(Class<?> type); static boolean isPrimitiveWrapper(Class<?> type); static String getPrimitiveTypeNameFromWrapper(Class<?> type); }### Answer:
@Test public void getWrapperType() { assertEquals(Void.class, PrimitiveUtils.getWrapperType(Void.TYPE)); assertEquals(Boolean.class, PrimitiveUtils.getWrapperType(Boolean.TYPE)); assertEquals(Byte.class, PrimitiveUtils.getWrapperType(Byte.TYPE)); assertEquals(Short.class, PrimitiveUtils.getWrapperType(Short.TYPE)); assertEquals(Character.class, PrimitiveUtils.getWrapperType(Character.TYPE)); assertEquals(Integer.class, PrimitiveUtils.getWrapperType(Integer.TYPE)); assertEquals(Long.class, PrimitiveUtils.getWrapperType(Long.TYPE)); assertEquals(Float.class, PrimitiveUtils.getWrapperType(Float.TYPE)); assertEquals(Double.class, PrimitiveUtils.getWrapperType(Double.TYPE)); } |
### Question:
PrimitiveUtils { public static boolean isPrimitiveWrapper(Class<?> type) { return wrapperTypes.containsKey(type); } private PrimitiveUtils(); static Object getEmptyValue(Class<?> type); static Class<?> getWrapperType(Class<?> type); static boolean isPrimitiveWrapper(Class<?> type); static String getPrimitiveTypeNameFromWrapper(Class<?> type); }### Answer:
@Test public void isNumberWrapper() { assertTrue(PrimitiveUtils.isPrimitiveWrapper(Byte.class)); assertTrue(PrimitiveUtils.isPrimitiveWrapper(Short.class)); assertTrue(PrimitiveUtils.isPrimitiveWrapper(Integer.class)); assertTrue(PrimitiveUtils.isPrimitiveWrapper(Long.class)); assertTrue(PrimitiveUtils.isPrimitiveWrapper(Float.class)); assertTrue(PrimitiveUtils.isPrimitiveWrapper(Double.class)); assertFalse(PrimitiveUtils.isPrimitiveWrapper(getClass())); assertFalse(PrimitiveUtils.isPrimitiveWrapper(Integer.TYPE)); } |
### Question:
PrimitiveUtils { public static String getPrimitiveTypeNameFromWrapper(Class<?> type) { return wrapperTypes.get(type); } private PrimitiveUtils(); static Object getEmptyValue(Class<?> type); static Class<?> getWrapperType(Class<?> type); static boolean isPrimitiveWrapper(Class<?> type); static String getPrimitiveTypeNameFromWrapper(Class<?> type); }### Answer:
@Test public void getPrimitiveTypeNameFromWrapper() { assertPrimitiveName(Byte.TYPE, Byte.class); assertPrimitiveName(Short.TYPE, Short.class); assertPrimitiveName(Integer.TYPE, Integer.class); assertPrimitiveName(Long.TYPE, Long.class); assertPrimitiveName(Float.TYPE, Float.class); assertPrimitiveName(Double.TYPE, Double.class); assertNull(PrimitiveUtils.getPrimitiveTypeNameFromWrapper(getClass())); assertNull(PrimitiveUtils.getPrimitiveTypeNameFromWrapper(Long.TYPE)); } |
### Question:
VerseHelper { static int positionToBookIndex(int position) throws IllegalArgumentException { if (position < 0) { throw new IllegalArgumentException("Invalid position: " + position); } final int bookCount = Bible.getBookCount(); for (int bookIndex = 0; bookIndex < bookCount; ++bookIndex) { final int chapterCount = Bible.getChapterCount(bookIndex); position -= chapterCount; if (position < 0) { return bookIndex; } } throw new IllegalArgumentException("Invalid position: " + position); } }### Answer:
@Test public void testPositionToBookIndex() { Assert.assertEquals(0, VerseHelper.positionToBookIndex(0)); Assert.assertEquals(0, VerseHelper.positionToBookIndex(49)); Assert.assertEquals(1, VerseHelper.positionToBookIndex(50)); Assert.assertEquals(1, VerseHelper.positionToBookIndex(55)); Assert.assertEquals(65, VerseHelper.positionToBookIndex(1188)); } |
### Question:
VerseHelper { static int positionToChapterIndex(int position) throws IllegalArgumentException { if (position < 0) { throw new IllegalArgumentException("Invalid position: " + position); } final int bookCount = Bible.getBookCount(); for (int bookIndex = 0; bookIndex < bookCount; ++bookIndex) { final int chapterCount = Bible.getChapterCount(bookIndex); if (position < chapterCount) { return position; } position -= chapterCount; } throw new IllegalArgumentException("Invalid position: " + position); } }### Answer:
@Test public void testPositionToChapterIndex() { Assert.assertEquals(0, VerseHelper.positionToChapterIndex(0)); Assert.assertEquals(49, VerseHelper.positionToChapterIndex(49)); Assert.assertEquals(0, VerseHelper.positionToChapterIndex(50)); Assert.assertEquals(5, VerseHelper.positionToChapterIndex(55)); Assert.assertEquals(21, VerseHelper.positionToChapterIndex(1188)); } |
### Question:
VerseHelper { static int indexToPosition(int bookIndex, int chapterIndex) throws IllegalArgumentException { final int bookCount = Bible.getBookCount(); if (bookIndex < 0 || bookIndex >= bookCount) { throw new IllegalArgumentException("Invalid book index: " + bookIndex); } final int chapterCount = Bible.getChapterCount(bookIndex); if (chapterIndex < 0 || chapterIndex >= chapterCount) { throw new IllegalArgumentException("Invalid chapter index: " + chapterIndex); } int position = 0; for (int i = 0; i < bookIndex; ++i) { position += Bible.getChapterCount(i); } return position + chapterIndex; } }### Answer:
@Test public void testIndexToPosition() { Assert.assertEquals(0, VerseHelper.indexToPosition(0, 0)); Assert.assertEquals(49, VerseHelper.indexToPosition(0, 49)); Assert.assertEquals(50, VerseHelper.indexToPosition(1, 0)); Assert.assertEquals(55, VerseHelper.indexToPosition(1, 5)); Assert.assertEquals(1188, VerseHelper.indexToPosition(65, 21)); } |
### Question:
LambdaServer implements HttpServer { @Override public boolean isMetricsEnabled() { return false; } LambdaServer(Vertx vertx, Context context, InputStream input, OutputStream output); @Override boolean isMetricsEnabled(); @Override ReadStream<HttpServerRequest> requestStream(); @Override HttpServer requestHandler(Handler<HttpServerRequest> handler); @Override Handler<HttpServerRequest> requestHandler(); @Override HttpServer connectionHandler(Handler<HttpConnection> handler); @Override ReadStream<ServerWebSocket> websocketStream(); @Override HttpServer websocketHandler(Handler<ServerWebSocket> handler); @Override Handler<ServerWebSocket> websocketHandler(); @Override HttpServer listen(); @Override HttpServer listen(int port, String host); @Override HttpServer listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(int port); @Override HttpServer listen(int port, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(Handler<AsyncResult<HttpServer>> listenHandler); @Override void close(); @Override void close(Handler<AsyncResult<Void>> completionHandler); @Override int actualPort(); }### Answer:
@Test public void testIsMetricsEnabled(TestContext context) { context.assertFalse(server.isMetricsEnabled()); } |
### Question:
LambdaServer implements HttpServer { @Override public ReadStream<HttpServerRequest> requestStream() { return null; } LambdaServer(Vertx vertx, Context context, InputStream input, OutputStream output); @Override boolean isMetricsEnabled(); @Override ReadStream<HttpServerRequest> requestStream(); @Override HttpServer requestHandler(Handler<HttpServerRequest> handler); @Override Handler<HttpServerRequest> requestHandler(); @Override HttpServer connectionHandler(Handler<HttpConnection> handler); @Override ReadStream<ServerWebSocket> websocketStream(); @Override HttpServer websocketHandler(Handler<ServerWebSocket> handler); @Override Handler<ServerWebSocket> websocketHandler(); @Override HttpServer listen(); @Override HttpServer listen(int port, String host); @Override HttpServer listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(int port); @Override HttpServer listen(int port, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(Handler<AsyncResult<HttpServer>> listenHandler); @Override void close(); @Override void close(Handler<AsyncResult<Void>> completionHandler); @Override int actualPort(); }### Answer:
@Test public void testRequestStream(TestContext context) { context.assertNull(server.requestStream()); } |
### Question:
LambdaServer implements HttpServer { @Override public HttpServer requestHandler(Handler<HttpServerRequest> handler) { this.requestHandler = handler; return this; } LambdaServer(Vertx vertx, Context context, InputStream input, OutputStream output); @Override boolean isMetricsEnabled(); @Override ReadStream<HttpServerRequest> requestStream(); @Override HttpServer requestHandler(Handler<HttpServerRequest> handler); @Override Handler<HttpServerRequest> requestHandler(); @Override HttpServer connectionHandler(Handler<HttpConnection> handler); @Override ReadStream<ServerWebSocket> websocketStream(); @Override HttpServer websocketHandler(Handler<ServerWebSocket> handler); @Override Handler<ServerWebSocket> websocketHandler(); @Override HttpServer listen(); @Override HttpServer listen(int port, String host); @Override HttpServer listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(int port); @Override HttpServer listen(int port, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(Handler<AsyncResult<HttpServer>> listenHandler); @Override void close(); @Override void close(Handler<AsyncResult<Void>> completionHandler); @Override int actualPort(); }### Answer:
@Test public void testRequestHandler(TestContext context) { Handler<HttpServerRequest> handler = new Handler<HttpServerRequest>() { @Override public void handle(HttpServerRequest event) { } }; context.assertEquals(server, server.requestHandler(handler)); context.assertEquals(handler, server.requestHandler()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public HttpServerRequest exceptionHandler(Handler<Throwable> handler) { return this; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testExceptionHandler(TestContext context) { context.assertEquals(request, request.exceptionHandler(ar -> { })); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public HttpServerRequest handler(Handler<Buffer> dataHandler) { checkEnded(); this.dataHandler = dataHandler; return this; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testHandler(TestContext context) { context.assertEquals(request, request.handler(ar -> { })); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public HttpServerRequest pause() { return this; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testPause(TestContext context) { context.assertEquals(request, request.pause()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public HttpServerRequest resume() { return this; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testResume(TestContext context) { context.assertEquals(request, request.resume()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public HttpServerRequest endHandler(Handler<Void> endHandler) { checkEnded(); this.endHandler = endHandler; return this; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testEndHandler(TestContext context) { context.assertEquals(request, request.endHandler(ar -> { request.response().end("data1"); })); request.handleEnd(); context.assertEquals("data1", new String(new JsonObject(Buffer.buffer(responseOutput.toByteArray())).getBinary("body"))); } |
### Question:
LambdaServer implements HttpServer { @Override public HttpServer connectionHandler(Handler<HttpConnection> handler) { return this; } LambdaServer(Vertx vertx, Context context, InputStream input, OutputStream output); @Override boolean isMetricsEnabled(); @Override ReadStream<HttpServerRequest> requestStream(); @Override HttpServer requestHandler(Handler<HttpServerRequest> handler); @Override Handler<HttpServerRequest> requestHandler(); @Override HttpServer connectionHandler(Handler<HttpConnection> handler); @Override ReadStream<ServerWebSocket> websocketStream(); @Override HttpServer websocketHandler(Handler<ServerWebSocket> handler); @Override Handler<ServerWebSocket> websocketHandler(); @Override HttpServer listen(); @Override HttpServer listen(int port, String host); @Override HttpServer listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(int port); @Override HttpServer listen(int port, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(Handler<AsyncResult<HttpServer>> listenHandler); @Override void close(); @Override void close(Handler<AsyncResult<Void>> completionHandler); @Override int actualPort(); }### Answer:
@Test public void testConnectionHandler(TestContext context) { context.assertEquals(server, server.connectionHandler(null)); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public HttpVersion version() { return HttpVersion.HTTP_1_1; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testVersion(TestContext context) { context.assertEquals(HttpVersion.HTTP_1_1, request.version()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public HttpMethod method() { return HttpMethod.valueOf(request.getString("httpMethod")); } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testMethod(TestContext context) { context.assertEquals(HttpMethod.POST, request.method()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public String rawMethod() { return request.getString("httpMethod"); } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testRawMethod(TestContext context) { context.assertEquals("POST", request.rawMethod()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public boolean isSSL() { return false; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testIsSSL(TestContext context) { context.assertFalse(request.isSSL()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public String scheme() { return "http"; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testScheme(TestContext context) { context.assertEquals("http", request.scheme()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public String uri() { if (uri == null) { String path = path().equals("/") ? "" : path(); uri = scheme() + ": if (query().length() > 0) { uri = uri + "?" + query(); }; } return uri; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testUri(TestContext context) { context.assertEquals("http: } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public String path() { return request.getString("path"); } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testPath(TestContext context) { context.assertEquals("/", request.path()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public String query() { if (query == null) { StringBuilder queryBuilder = new StringBuilder(); for (Map.Entry<String, String> param : params()) { if (queryBuilder.length() > 0) { queryBuilder.append("&"); } queryBuilder.append(urlEncode(param.getKey())); queryBuilder.append("="); queryBuilder.append(urlEncode(param.getValue())); } query = queryBuilder.toString(); } return query; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testQuery(TestContext context) { context.assertEquals("p1=1&p2=2", request.query()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public String host() { return localHost; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testHost(TestContext context) { context.assertEquals("localhost", request.host()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public HttpServerResponse response() { return response; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testResponse(TestContext context) { context.assertEquals(response, request.response()); } |
### Question:
LambdaServer implements HttpServer { @Override public ReadStream<ServerWebSocket> websocketStream() { return null; } LambdaServer(Vertx vertx, Context context, InputStream input, OutputStream output); @Override boolean isMetricsEnabled(); @Override ReadStream<HttpServerRequest> requestStream(); @Override HttpServer requestHandler(Handler<HttpServerRequest> handler); @Override Handler<HttpServerRequest> requestHandler(); @Override HttpServer connectionHandler(Handler<HttpConnection> handler); @Override ReadStream<ServerWebSocket> websocketStream(); @Override HttpServer websocketHandler(Handler<ServerWebSocket> handler); @Override Handler<ServerWebSocket> websocketHandler(); @Override HttpServer listen(); @Override HttpServer listen(int port, String host); @Override HttpServer listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(int port); @Override HttpServer listen(int port, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(Handler<AsyncResult<HttpServer>> listenHandler); @Override void close(); @Override void close(Handler<AsyncResult<Void>> completionHandler); @Override int actualPort(); }### Answer:
@Test public void testWebsocketStream(TestContext context) { context.assertNull(server.websocketStream()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public MultiMap headers() { if (headers == null) { headers = MultiMap.caseInsensitiveMultiMap(); JsonObject requestHeaders = request.getJsonObject("headers"); if (requestHeaders != null) { for (Map.Entry<String, Object> entry : requestHeaders) { headers.add(entry.getKey(), entry.getValue().toString()); } } } return headers; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testHeaders(TestContext context) { context.assertEquals("val1", request.headers().get("X-H1")); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public String getHeader(String headerName) { return headers().get(headerName); } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testGetHeader(TestContext context) { context.assertEquals("val1", request.getHeader("X-H1")); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public MultiMap params() { if (params == null) { params = new CaseSensitiveMultiMapImpl(); JsonObject queryParams = request.getJsonObject("queryStringParameters"); if (queryParams != null) { for (Map.Entry<String, Object> entry : queryParams) { params.add(entry.getKey(), entry.getValue().toString()); } } } return params; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testParams(TestContext context) { MultiMap params = request.params(); context.assertEquals(2, params.size()); context.assertEquals("1", params.get("p1")); context.assertEquals("2", params.get("p2")); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public String getParam(String paramName) { return params().get(paramName); } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testGetParam(TestContext context) { context.assertEquals("1", request.getParam("p1")); context.assertEquals("2", request.getParam("p2")); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public SocketAddress localAddress() { if (localAddress == null) { localAddress = new SocketAddress() { @Override public String host() { return localHost; } @Override public int port() { return localPort; } }; } return localAddress; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testLocalAddress(TestContext context) { SocketAddress address = request.localAddress(); context.assertEquals("localhost", address.host()); context.assertEquals(8888, address.port()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public X509Certificate[] peerCertificateChain() throws SSLPeerUnverifiedException { return null; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testPeerCertificateChain(TestContext context) throws SSLPeerUnverifiedException { context.assertNull(request.peerCertificateChain()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public String absoluteURI() { if (absoluteURI == null) { absoluteURI = uri(); } return absoluteURI; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testAbsoluteURI(TestContext context) { context.assertEquals("http: } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public NetSocket netSocket() { return null; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testNetSocket(TestContext context) { context.assertNull(request.netSocket()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public HttpServerRequest setExpectMultipart(boolean expect) { checkEnded(); if (expect) { throw new java.lang.UnsupportedOperationException("Not supported yet."); } return this; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test(expected = java.lang.UnsupportedOperationException.class) public void testSetExpectMultipart(TestContext context) { request.setExpectMultipart(true); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public boolean isExpectMultipart() { return false; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testIsExpectMultipart(TestContext context) { context.assertFalse(request.isExpectMultipart()); } |
### Question:
LambdaServer implements HttpServer { @Override public HttpServer websocketHandler(Handler<ServerWebSocket> handler) { this.websocketHandler = handler; return this; } LambdaServer(Vertx vertx, Context context, InputStream input, OutputStream output); @Override boolean isMetricsEnabled(); @Override ReadStream<HttpServerRequest> requestStream(); @Override HttpServer requestHandler(Handler<HttpServerRequest> handler); @Override Handler<HttpServerRequest> requestHandler(); @Override HttpServer connectionHandler(Handler<HttpConnection> handler); @Override ReadStream<ServerWebSocket> websocketStream(); @Override HttpServer websocketHandler(Handler<ServerWebSocket> handler); @Override Handler<ServerWebSocket> websocketHandler(); @Override HttpServer listen(); @Override HttpServer listen(int port, String host); @Override HttpServer listen(int port, String host, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(int port); @Override HttpServer listen(int port, Handler<AsyncResult<HttpServer>> listenHandler); @Override HttpServer listen(Handler<AsyncResult<HttpServer>> listenHandler); @Override void close(); @Override void close(Handler<AsyncResult<Void>> completionHandler); @Override int actualPort(); }### Answer:
@Test public void testWebsocketHandler(TestContext context) { Handler<ServerWebSocket> handler = new Handler<ServerWebSocket>() { @Override public void handle(ServerWebSocket event) { } }; context.assertEquals(server, server.websocketHandler(handler)); context.assertEquals(handler, server.websocketHandler()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler) { checkEnded(); return this; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testUploadHandler(TestContext context) { context.assertEquals(request, request.uploadHandler(p -> { })); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public MultiMap formAttributes() { if (attributes == null) { attributes = MultiMap.caseInsensitiveMultiMap(); } return attributes; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testformAttributes(TestContext context) { MultiMap attr = request.formAttributes(); context.assertEquals(0, attr.size()); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public String getFormAttribute(String attributeName) { return formAttributes().get(attributeName); } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testGetFormAttribute(TestContext context) { context.assertNull(request.getFormAttribute("X")); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public ServerWebSocket upgrade() { throw new java.lang.UnsupportedOperationException("Not supported yet."); } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test(expected = java.lang.UnsupportedOperationException.class) public void testUpgrade(TestContext context) { request.upgrade(); } |
### Question:
HttpServerRequestImpl implements HttpServerRequest { @Override public boolean isEnded() { return ended; } HttpServerRequestImpl(String localHost, int localPort, JsonObject request, HttpServerResponse response); @Override HttpServerRequest exceptionHandler(Handler<Throwable> handler); @Override HttpServerRequest handler(Handler<Buffer> dataHandler); @Override HttpServerRequest pause(); @Override HttpServerRequest resume(); @Override HttpServerRequest endHandler(Handler<Void> endHandler); @Override HttpVersion version(); @Override HttpMethod method(); @Override String rawMethod(); @Override boolean isSSL(); @Override String scheme(); @Override String uri(); @Override String path(); @Override String query(); @Override String host(); @Override HttpServerResponse response(); @Override MultiMap headers(); @Override String getHeader(String headerName); @Override String getHeader(CharSequence headerName); @Override MultiMap params(); @Override String getParam(String paramName); @Override SocketAddress remoteAddress(); @Override SocketAddress localAddress(); @Override X509Certificate[] peerCertificateChain(); @Override String absoluteURI(); @Override NetSocket netSocket(); @Override HttpServerRequest setExpectMultipart(boolean expect); @Override boolean isExpectMultipart(); @Override HttpServerRequest uploadHandler(Handler<HttpServerFileUpload> uploadHandler); @Override MultiMap formAttributes(); @Override String getFormAttribute(String attributeName); @Override ServerWebSocket upgrade(); @Override boolean isEnded(); @Override HttpServerRequest customFrameHandler(Handler<HttpFrame> handler); @Override HttpConnection connection(); void handleData(); void handleEnd(); }### Answer:
@Test public void testIsEnded(TestContext context) { context.assertFalse(request.isEnded()); request.handleEnd(); context.assertTrue(request.isEnded()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.