method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
GsonFactory { public static Gson create() { GsonBuilder gsonBuilder = new GsonBuilder(); gsonBuilder.excludeFieldsWithoutExposeAnnotation(); gsonBuilder.disableHtmlEscaping(); gsonBuilder.registerTypeAdapterFactory(new ReportLookupTypeAdapterFactory()); gsonBuilder.registerTypeAdapterFactory(new InputControlTypeAdapterFactory()); gsonBuilder.registerTypeAdapterFactory(new ReportExecutionRequestOptionsFactory()); gsonBuilder.registerTypeAdapterFactory(new DashboardComponentTypeAdapterFactory()); gsonBuilder.registerTypeAdapterFactory(new JobSourceParamsWrapperTypeAdapterFactory()); return gsonBuilder.create(); } static Gson create(); }### Answer:
@Test public void shouldEnableGsonExposeAnnotationField() throws Exception { GsonBuilder gsonBuilder = PowerMockito.mock(GsonBuilder.class); whenNew(GsonBuilder.class).withNoArguments().thenReturn(gsonBuilder); GsonFactory.create(); verify(gsonBuilder, times(1)).excludeFieldsWithoutExposeAnnotation(); }
@Test public void shouldDisableHtmlEscaping() throws Exception { GsonBuilder gsonBuilder = PowerMockito.mock(GsonBuilder.class); whenNew(GsonBuilder.class).withNoArguments().thenReturn(gsonBuilder); GsonFactory.create(); verify(gsonBuilder, times(1)).disableHtmlEscaping(); }
@Test public void shouldCreateInstanceOfGson() { Gson gson = GsonFactory.create(); assertThat(gson, Is.is(notNullValue())); }
@Test public void shouldModifyReportExecutionParametersField() throws Exception { ReportExecutionRequestOptions options = ReportExecutionRequestOptions.newRequest("/my/uri"); options.withParameters(Collections.singletonList(new ReportParameter("key", Collections.singleton("value")))); Gson gson = GsonFactory.create(); assertThat(gson.toJson(options), is("{\"reportUnitUri\":\"/my/uri\",\"parameters\":{\"reportParameter\":[{\"name\":\"key\",\"value\":[\"value\"]}]}}")); }
@Test public void should_parse_only_input_controls_from_dashboard_components() throws Exception { Gson gson = GsonFactory.create(); DashboardComponentCollection components = gson.fromJson(mComponents.asString(), DashboardComponentCollection.class); assertThat(components.getInputControlComponents() , is(not(empty()))); }
@Test public void should_deserialize_form_with_custom_rule() throws Exception { Gson gson = GsonFactory.create(); JobFormEntity entity = gson.fromJson(mGetJobResponse.asString(), JobFormEntity.class); assertThat(entity , is(notNullValue())); } |
### 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:
ReportOptionRestApi { @NotNull public Set<ReportOptionEntity> requestReportOptionsList( @NotNull String reportUnitUri) throws IOException, HttpException { Utils.checkNotNull(reportUnitUri, "Report uri should not be null"); HttpUrl url = new PathResolver.Builder() .addPath("rest_v2") .addPath("reports") .addPaths(reportUnitUri) .addPath("options") .build() .resolve(mNetworkClient.getBaseUrl()); Request request = new Request.Builder() .addHeader("Accept", "application/json; charset=UTF-8") .get() .url(url) .build(); Response response = mNetworkClient.makeCall(request); try { ReportOptionSet reportOptionSet = mNetworkClient.deserializeJson(response, ReportOptionSet.class); return Collections.unmodifiableSet(reportOptionSet.get()); } catch (JsonSyntaxException ex) { return Collections.emptySet(); } } ReportOptionRestApi(NetworkClient networkClient); @NotNull Set<ReportOptionEntity> requestReportOptionsList(
@NotNull String reportUnitUri); @NotNull ReportOptionEntity createReportOption(
@NotNull String reportUnitUri,
@NotNull String optionLabel,
@NotNull List<ReportParameter> parameters,
boolean overwrite); void updateReportOption(
@NotNull String reportUnitUri,
@NotNull String optionId,
@NotNull List<ReportParameter> parameters); void deleteReportOption(
@Nullable String reportUnitUri,
@Nullable String optionId); }### Answer:
@Test public void requestReportOptionsListShouldNotAllowNullReportUnitUri() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Report uri should not be null"); restApiUnderTest.requestReportOptionsList(null); }
@Test public void apiShouldListReportOptions() throws Exception { MockResponse mockResponse = MockResponseFactory.create200().setBody(reportOptionsList.asString()); mWebMockRule.enqueue(mockResponse); Set<ReportOptionEntity> response = restApiUnderTest.requestReportOptionsList("/any/uri"); assertThat(response, is(not(empty()))); RecordedRequest request = mWebMockRule.get().takeRequest(); assertThat(request.getPath(), is("/rest_v2/reports/any/uri/options")); }
@Test public void requestReportOptionsListShouldThrow500Error() throws Exception { mExpectedException.expect(HttpException.class); mWebMockRule.enqueue(MockResponseFactory.create500()); restApiUnderTest.requestReportOptionsList("any_id"); } |
### Question:
ReportOptionRestApi { @NotNull public ReportOptionEntity createReportOption( @NotNull String reportUnitUri, @NotNull String optionLabel, @NotNull List<ReportParameter> parameters, boolean overwrite) throws IOException, HttpException { Utils.checkNotNull(reportUnitUri, "Report uri should not be null"); Utils.checkNotNull(optionLabel, "Option label should not be null"); Utils.checkNotNull(parameters, "Parameters values should not be null"); HttpUrl url = new PathResolver.Builder() .addPath("rest_v2") .addPath("reports") .addPaths(reportUnitUri) .addPath("options") .build() .resolve(mNetworkClient.getBaseUrl()) .newBuilder() .addQueryParameter("label", optionLabel) .addQueryParameter("overwrite", String.valueOf(overwrite)) .build(); Map<String, Set<String>> controlsValues = ReportParamsMapper.INSTANCE.toMap(parameters); RequestBody requestBody = mNetworkClient.createJsonRequestBody(controlsValues); Request request = new Request.Builder() .addHeader("Accept", "application/json; charset=UTF-8") .post(requestBody) .url(url) .build(); Response response = mNetworkClient.makeCall(request); return mNetworkClient.deserializeJson(response, ReportOptionEntity.class); } ReportOptionRestApi(NetworkClient networkClient); @NotNull Set<ReportOptionEntity> requestReportOptionsList(
@NotNull String reportUnitUri); @NotNull ReportOptionEntity createReportOption(
@NotNull String reportUnitUri,
@NotNull String optionLabel,
@NotNull List<ReportParameter> parameters,
boolean overwrite); void updateReportOption(
@NotNull String reportUnitUri,
@NotNull String optionId,
@NotNull List<ReportParameter> parameters); void deleteReportOption(
@Nullable String reportUnitUri,
@Nullable String optionId); }### Answer:
@Test public void createReportOptionShouldNotAllowNullReportUri() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Report uri should not be null"); restApiUnderTest.createReportOption(null, "label", REPORT_PARAMS, false); }
@Test public void createReportOptionShouldNotAllowNullOptionLabel() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Option label should not be null"); restApiUnderTest.createReportOption("any_id", null, REPORT_PARAMS, false); }
@Test public void createReportOptionShouldNotAllowNullControlsValues() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Parameters values should not be null"); restApiUnderTest.createReportOption("any_id", "label", null, false); }
@Test public void apiShouldCreateReportOption() throws Exception { MockResponse mockResponse = MockResponseFactory.create200().setBody(reportOption.asString()); mWebMockRule.enqueue(mockResponse); ReportOptionEntity reportOption = restApiUnderTest.createReportOption("/any/uri", "my label", REPORT_PARAMS, true); assertThat(reportOption.getId(), is("my_label")); assertThat(reportOption.getLabel(), is("my label")); assertThat(reportOption.getUri(), is("/public/Samples/Reports/my_label")); RecordedRequest request = mWebMockRule.get().takeRequest(); assertThat(request.getPath(), is("/rest_v2/reports/any/uri/options?label=my%20label&overwrite=true")); assertThat(request.getBody().readUtf8(), is("{\"sales_fact_ALL__store_sales_2013_1\":[\"19\"]}")); } |
### Question:
ReportOptionRestApi { public void updateReportOption( @NotNull String reportUnitUri, @NotNull String optionId, @NotNull List<ReportParameter> parameters) throws IOException, HttpException { Utils.checkNotNull(reportUnitUri, "Report uri should not be null"); Utils.checkNotNull(optionId, "Option id should not be null"); Utils.checkNotNull(parameters, "Parameters values should not be null"); HttpUrl url = new PathResolver.Builder() .addPath("rest_v2") .addPath("reports") .addPaths(reportUnitUri) .addPath("options") .addPath(optionId) .build() .resolve(mNetworkClient.getBaseUrl()); Map<String, Set<String>> controlsValues = ReportParamsMapper.INSTANCE.toMap(parameters); RequestBody requestBody = mNetworkClient.createJsonRequestBody(controlsValues); Request request = new Request.Builder() .addHeader("Accept", "application/json; charset=UTF-8") .put(requestBody) .url(url) .build(); mNetworkClient.makeCall(request); } ReportOptionRestApi(NetworkClient networkClient); @NotNull Set<ReportOptionEntity> requestReportOptionsList(
@NotNull String reportUnitUri); @NotNull ReportOptionEntity createReportOption(
@NotNull String reportUnitUri,
@NotNull String optionLabel,
@NotNull List<ReportParameter> parameters,
boolean overwrite); void updateReportOption(
@NotNull String reportUnitUri,
@NotNull String optionId,
@NotNull List<ReportParameter> parameters); void deleteReportOption(
@Nullable String reportUnitUri,
@Nullable String optionId); }### Answer:
@Test public void updateReportOptionShouldNotAllowNullReportUri() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Report uri should not be null"); restApiUnderTest.updateReportOption(null, "option_id", REPORT_PARAMS); }
@Test public void updateReportOptionShouldNotAllowNullOptionId() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Option id should not be null"); restApiUnderTest.updateReportOption("any_id", null, REPORT_PARAMS); }
@Test public void updateReportOptionShouldNotAllowNullControlsValues() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Parameters values should not be null"); restApiUnderTest.updateReportOption("any_id", "option_id", null); }
@Test public void apiShouldUpdateReportOption() throws Exception { mWebMockRule.enqueue(MockResponseFactory.create200()); Map<String, Set<String>> params = new HashMap<>(); params.put("sales_fact_ALL__store_sales_2013_1", Collections.singleton("22")); restApiUnderTest.updateReportOption("/any/uri", "option_id", REPORT_PARAMS); RecordedRequest request = mWebMockRule.get().takeRequest(); assertThat(request.getPath(), is("/rest_v2/reports/any/uri/options/option_id")); assertThat(request.getMethod(), is("PUT")); }
@Test public void updateReportOptionShouldThrowRestErrorFor500() throws Exception { mExpectedException.expect(HttpException.class); mWebMockRule.enqueue(MockResponseFactory.create500()); restApiUnderTest.updateReportOption("any_id", "option_id", REPORT_PARAMS); } |
### Question:
ReportOptionRestApi { public void deleteReportOption( @Nullable String reportUnitUri, @Nullable String optionId) throws IOException, HttpException { Utils.checkNotNull(reportUnitUri, "Report uri should not be null"); Utils.checkNotNull(optionId, "Option id should not be null"); HttpUrl url = new PathResolver.Builder() .addPath("rest_v2") .addPath("reports") .addPaths(reportUnitUri) .addPath("options") .addPath(optionId) .build() .resolve(mNetworkClient.getBaseUrl()); Request request = new Request.Builder() .addHeader("Accept", "application/json; charset=UTF-8") .delete() .url(url) .build(); mNetworkClient.makeCall(request); } ReportOptionRestApi(NetworkClient networkClient); @NotNull Set<ReportOptionEntity> requestReportOptionsList(
@NotNull String reportUnitUri); @NotNull ReportOptionEntity createReportOption(
@NotNull String reportUnitUri,
@NotNull String optionLabel,
@NotNull List<ReportParameter> parameters,
boolean overwrite); void updateReportOption(
@NotNull String reportUnitUri,
@NotNull String optionId,
@NotNull List<ReportParameter> parameters); void deleteReportOption(
@Nullable String reportUnitUri,
@Nullable String optionId); }### Answer:
@Test public void deleteReportOptionShouldNotAllowNullReportUri() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Report uri should not be null"); restApiUnderTest.deleteReportOption(null, "option_id"); }
@Test public void deleteReportOptionShouldNotAllowNullOptionId() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Option id should not be null"); restApiUnderTest.deleteReportOption("any_id", null); }
@Test public void apiShouldDeleteReportOption() throws Exception { mWebMockRule.enqueue(MockResponseFactory.create200()); restApiUnderTest.deleteReportOption("/any/uri", "option_id"); RecordedRequest request = mWebMockRule.get().takeRequest(); assertThat(request.getPath(), is("/rest_v2/reports/any/uri/options/option_id")); assertThat(request.getMethod(), is("DELETE")); }
@Test public void deleteReportOptionShouldThrowRestErrorFor500() throws Exception { mExpectedException.expect(HttpException.class); mWebMockRule.enqueue(MockResponseFactory.create500()); restApiUnderTest.deleteReportOption("any_id", "option_id"); } |
### 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 runReportExecution(@NotNull ReportExecutionRequestOptions executionOptions) throws IOException, HttpException { Utils.checkNotNull(executionOptions, "Execution options should not be null"); HttpUrl url = mNetworkClient.getBaseUrl().resolve("rest_v2/reportExecutions"); RequestBody jsonRequestBody = mNetworkClient.createJsonRequestBody(executionOptions); Request request = new Request.Builder() .addHeader("Accept", "application/json; charset=UTF-8") .post(jsonRequestBody) .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 shouldThroughRestErrorOnSearchRequestIfHttpError() throws Exception { mExpectedException.expect(HttpException.class); mWebMockRule.enqueue(MockResponseFactory.create500()); restApiUnderTest.runReportExecution(ReportExecutionRequestOptions.newRequest("/any/uri")); }
@Test public void bodyParameterShouldNotBeNullForRunReportExecution() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Execution options should not be null"); restApiUnderTest.runReportExecution(null); }
@Test public void shouldStartReportExecution() throws Exception { MockResponse response = MockResponseFactory.create200().setBody(reportExecutionResponse.asString()); mWebMockRule.enqueue(response); ReportExecutionRequestOptions options = ReportExecutionRequestOptions.newRequest("/my/uri"); restApiUnderTest.runReportExecution(options); RecordedRequest request = mWebMockRule.get().takeRequest(); assertThat(request, containsHeader("Accept", "application/json; charset=UTF-8")); assertThat(request, hasPath("/rest_v2/reportExecutions")); assertThat(request, wasMethod("POST")); assertThat(request, hasBody("{\"reportUnitUri\":\"/my/uri\"}")); } |
### 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:
ReportExecutionRestApi { public boolean cancelReportExecution(@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(); RequestBody jsonRequestBody = mNetworkClient.createJsonRequestBody(ExecutionStatus.cancelledStatus()); Request request = new Request.Builder() .addHeader("Accept", "application/json; charset=UTF-8") .put(jsonRequestBody) .url(url) .build(); com.squareup.okhttp.Response response = mNetworkClient.makeCall(request); int status = response.code(); return status != 204; } 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 executionIdShouldNotBeNullForCancelRequestExecution() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Execution id should not be null"); restApiUnderTest.cancelReportExecution(null); }
@Test public void shouldCancelReportExecution() throws Exception { MockResponse response = MockResponseFactory.create200(); mWebMockRule.enqueue(response); restApiUnderTest.cancelReportExecution(EXEC_ID); 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, hasBody("{\"value\":\"cancelled\"}")); assertThat(request, wasMethod("PUT")); }
@Test public void responseShouldNotBeCancelledIfResponseIs204() throws Exception { mWebMockRule.enqueue(MockResponseFactory.create204()); boolean cancelled = restApiUnderTest.cancelReportExecution("any_id"); assertThat(cancelled, is(false)); }
@Test public void responseShouldBeCancelledIfResponseIs200() throws Exception { MockResponse response = MockResponseFactory.create200().setBody(cancelledResponse.asString()); mWebMockRule.enqueue(response); boolean cancelled = restApiUnderTest.cancelReportExecution("any_id"); assertThat(cancelled, is(true)); } |
### Question:
ReportExecutionRestApi { public boolean updateReportExecution(@NotNull String executionId, @NotNull List<ReportParameter> params) throws IOException, HttpException { Utils.checkNotNull(executionId, "Execution id should not be null"); Utils.checkNotNull(params, "Execution params should not be null"); Utils.checkArgument(params.isEmpty(), "Execution params should not be empty"); HttpUrl url = mNetworkClient.getBaseUrl() .resolve("rest_v2/reportExecutions") .newBuilder() .addPathSegment(executionId) .addPathSegment("parameters") .build(); RequestBody jsonRequestBody = mNetworkClient.createJsonRequestBody(params); Request request = new Request.Builder() .addHeader("Accept", "application/json; charset=UTF-8") .post(jsonRequestBody) .url(url) .build(); com.squareup.okhttp.Response response = mNetworkClient.makeCall(request); int status = response.code(); return status == 204; } 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 bodyParameterShouldNotBeNullForExecutionUpdate() throws Exception { mExpectedException.expect(NullPointerException.class); mExpectedException.expectMessage("Execution params should not be null"); restApiUnderTest.updateReportExecution("any_id", null); }
@Test public void bodyParameterShouldNotBeEmptyForExecutionUpdate() throws Exception { mExpectedException.expect(IllegalArgumentException.class); mExpectedException.expectMessage("Execution params should not be empty"); restApiUnderTest.updateReportExecution("any_id", Collections.<ReportParameter>emptyList()); }
@Test public void shouldUpdateReportExecution() throws Exception { MockResponse response = MockResponseFactory.create204(); mWebMockRule.enqueue(response); restApiUnderTest.updateReportExecution(EXEC_ID, PARAMS); 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/parameters")); assertThat(request, hasBody("[{\"name\":\"key\",\"value\":[\"value\"]}]")); assertThat(request, wasMethod("POST")); }
@Test public void executionUpdateRequestShouldBeSuccessIfResponseIs204() throws Exception { mWebMockRule.enqueue(MockResponseFactory.create204()); boolean response = restApiUnderTest.updateReportExecution("any_id", PARAMS); assertThat(response, is(true)); } |
### 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:
AuthRestApi { @NotNull public EncryptionKey requestEncryptionMetadata() throws IOException, HttpException { HttpUrl url2 = mNetworkClient.getBaseUrl().resolve("GetEncryptionKey"); Request request2 = new Request.Builder() .addHeader("Accept", "application/json; charset=UTF-8") .url(url2) .get() .build(); try { Response response = mNetworkClient.makeRawCall(request2); int code = response.code(); if (code >= 200 && code < 300) { return mNetworkClient.deserializeJson(response, EncryptionKey.class); } else { return EncryptionKey.empty(); } } catch (JsonSyntaxException ex) { return EncryptionKey.empty(); } } AuthRestApi(@NotNull NetworkClient client); void springAuth(@NotNull final String username,
@NotNull final String password,
final String organization,
final Map<String, String> params); @NotNull EncryptionKey requestEncryptionMetadata(); }### Answer:
@Test public void shouldReturnEncryptionKeyIfApiAvailable() throws Exception { MockResponse encryptionKey = MockResponseFactory.create200() .setBody(mKey.asString()); mWebMockRule.enqueue(encryptionKey); EncryptionKey keyResponse = apiUnderTest.requestEncryptionMetadata(); assertThat(keyResponse, Is.is(notNullValue())); }
@Test public void shouldReturnEmptyEncryptionKeyIfApiNotAvailable() throws Exception { String malformedJson = "{Error: Key generation is off}"; MockResponse encryptionKey = MockResponseFactory.create200() .setBody(malformedJson); mWebMockRule.enqueue(encryptionKey); EncryptionKey keyResponse = apiUnderTest.requestEncryptionMetadata(); assertThat(keyResponse.isAvailable(), Is.is(false)); }
@Test public void shouldReturnEmptyEncryptionKeyIfApiReturns401Error() throws Exception { MockResponse anonymousCookie = MockResponseFactory.create200() .setBody("6.1") .addHeader("Set-Cookie", "cookie1=12"); String malformedJson = "{Error: Key generation is off}"; MockResponse encryptionKey = MockResponseFactory.create401() .setBody(malformedJson); mWebMockRule.enqueue(anonymousCookie); mWebMockRule.enqueue(encryptionKey); EncryptionKey keyResponse = apiUnderTest.requestEncryptionMetadata(); assertThat(keyResponse.isAvailable(), is(false)); } |
### Question:
ViPRResponsesSaxParser extends XmlResponsesSaxParser { public FileAccessResultHandler parseFileAccessResult(InputStream inputStream) throws AmazonClientException { FileAccessResultHandler handler = new FileAccessResultHandler(); parseXmlInputStream(handler, inputStream); return handler; } FileAccessResultHandler parseFileAccessResult(InputStream inputStream); ListDataNodesResultHandler parseListDataNodeResult(InputStream inputStream); }### Answer:
@Test public void testFileAccessResult() throws Exception { String rawXml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" + " <fileaccess_response>\n" + " <mountPoints>no_idea_what_goes_here</mountPoints>\n" + " <mountPoints>no_idea_what_goes_here</mountPoints>\n" + " <objects>\n" + " <name>foo</name>\n" + " <deviceExport>cifs: " <relativePath>foo</relativePath>\n" + " <owner>some_guy</owner>\n" + " </objects>\n" + " <objects>\n" + " <name>blah</name>\n" + " <deviceExport>nfs: " <relativePath>blah</relativePath>\n" + " <owner>some_girl</owner>\n" + " </objects>\n" + " </fileaccess_response>"; GetFileAccessResult result = new ViPRResponsesSaxParser().parseFileAccessResult(new StringInputStream(rawXml)).getResult(); Assert.assertNotNull("result is null", result); Assert.assertEquals("wrong mount point number", 2, result.getMountPoints().size()); Assert.assertEquals("wrong object number", 2, result.getObjects().size()); Assert.assertEquals("wrong mount point value", "no_idea_what_goes_here", result.getMountPoints().get(0)); Assert.assertEquals("wrong mount point value", "no_idea_what_goes_here", result.getMountPoints().get(1)); FileAccessObject object = result.getObjects().get(0); Assert.assertEquals("wrong object name", "foo", object.getName()); Assert.assertEquals("wrong object export", "cifs: Assert.assertEquals("wrong object relative path", "foo", object.getRelativePath()); Assert.assertEquals("wrong object owner", "some_guy", object.getOwner()); object = result.getObjects().get(1); Assert.assertEquals("wrong object name", "blah", object.getName()); Assert.assertEquals("wrong object export", "nfs: Assert.assertEquals("wrong object relative path", "blah", object.getRelativePath()); Assert.assertEquals("wrong object owner", "some_girl", object.getOwner()); } |
### 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:
KeyUtils { public static String encryptKey(SecretKey key, Provider provider, PublicKey publicKey) throws GeneralSecurityException { Cipher cipher = null; if(provider != null) { cipher = Cipher.getInstance(TransformConstants.KEY_ENCRYPTION_TRANSFORM, provider); } else { cipher = Cipher.getInstance(TransformConstants.KEY_ENCRYPTION_TRANSFORM); } cipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] encryptedKey = cipher.doFinal(key.getEncoded()); return urlSafeEncodeBase64(encryptedKey); } 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 testEncryptBadKey() throws GeneralSecurityException { KeyGenerator kg; try { if(provider != null) { kg = KeyGenerator.getInstance("AES", provider); } else { kg = KeyGenerator.getInstance("AES"); } } catch(NoSuchAlgorithmException e) { throw new RuntimeException(e); } kg.init(128); SecretKey sk = kg.generateKey(); KeyPairGenerator kpg; try { if(provider != null) { kpg = KeyPairGenerator.getInstance("DSA", provider); } else { kpg = KeyPairGenerator.getInstance("DSA"); } } catch(NoSuchAlgorithmException e) { throw new RuntimeException(e); } KeyPair dsa = kpg.generateKeyPair(); KeyUtils.encryptKey(sk, null, dsa.getPublic()); } |
### Question:
BasicEncryptionTransformFactory extends
EncryptionTransformFactory<BasicEncryptionOutputTransform, BasicEncryptionInputTransform> { public void setMasterEncryptionKey(KeyPair pair) { if (!(pair.getPublic() instanceof RSAPublicKey)) { throw new IllegalArgumentException( "Only RSA KeyPairs are allowed, not " + pair.getPublic().getAlgorithm()); } checkKeyLength(pair); this.masterEncryptionKey = pair; try { this.masterEncryptionKeyFingerprint = KeyUtils .getRsaPublicKeyFingerprint((RSAPublicKey) pair.getPublic(), provider); } catch (NoSuchAlgorithmException e) { throw new RuntimeException("Error adding master key", e); } addMasterDecryptionKey(pair); } 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 testRejectSmallKey() throws Exception { BasicEncryptionTransformFactory factory = new BasicEncryptionTransformFactory(); factory.setCryptoProvider(provider); KeyPair smallKey = null; try { smallKey = KeyUtils.rsaKeyPairFromBase64( keyprops.getProperty("smallkey.public"), keyprops.getProperty("smallkey.private")); } catch (Exception e) { logger.info("Key was properly rejected by JVM: " + e); return; } try { factory.setMasterEncryptionKey(smallKey); } catch (Exception e) { logger.info("Key was properly rejected by factory: " + e); return; } fail("RSA key < 1024 bits should have been rejected by factory"); }
@Test public void testSetMasterEncryptionKey() throws Exception { BasicEncryptionTransformFactory factory = new BasicEncryptionTransformFactory(); factory.setCryptoProvider(provider); factory.setMasterEncryptionKey(masterKey); }
@Test public void testRejectNonRsaMasterKey() throws Exception { KeyPairGenerator keyGenerator = KeyPairGenerator.getInstance("DSA"); keyGenerator.initialize(512, new SecureRandom()); KeyPair myKeyPair = keyGenerator.generateKeyPair(); BasicEncryptionTransformFactory factory = new BasicEncryptionTransformFactory(); factory.setCryptoProvider(provider); try { factory.setMasterEncryptionKey(myKeyPair); } catch (Exception e) { logger.info("DSA key was properly rejected by factory: " + e); return; } fail("DSA keys should not be allowed."); } |
### 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:
CompressionTransformFactory extends
TransformFactory<CompressionOutputTransform, CompressionInputTransform> { @Override public CompressionInputTransform getInputTransform(String transformConfig, InputStream streamToDecode, Map<String, String> metadata) throws IOException { String[] transformTuple = splitTransformConfig(transformConfig); if(!TransformConstants.COMPRESSION_CLASS.equals(transformTuple[0])) { throw new IllegalArgumentException("Unsupported transform class: " + transformTuple[0]); } String[] configParams = transformTuple[1].split("/"); if(configParams.length < 1) { throw new IllegalArgumentException("Could not decode configuration: " + configParams); } CompressionMode mode = CompressionMode.valueOf(configParams[0]); switch(mode) { case Deflate: return new DeflateInputTransform(streamToDecode, metadata); case LZMA: return new LZMAInputTransform(streamToDecode, metadata); default: throw new IllegalArgumentException("Unknown compression method " + mode); } } 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 testGetInputTransform() throws IOException { CompressionTransformFactory factory = new CompressionTransformFactory(); byte[] lzmaConfig = new byte[] { 0, 0, 0, 0, 0 }; CompressionInputTransform t = factory.getInputTransform("COMP:LZMA/9", new ByteArrayInputStream(lzmaConfig), new HashMap<String, String>()); assertNotNull("input transform null", t); } |
### Question:
CompressionTransformFactory extends
TransformFactory<CompressionOutputTransform, CompressionInputTransform> { public boolean canDecode(String transformClass, String config, Map<String,String> metadata) { if(config == null) { logger.warn("Configuration string null"); return false; } String[] configParams = config.split("/"); if(configParams.length < 1) { logger.warn("Could not decode config string {}", config); return false; } try { CompressionMode.valueOf(configParams[0]); } catch(IllegalArgumentException e) { logger.warn("Invalid compression mode {}", configParams[0]); return false; } return getTransformClass().equals(transformClass); } 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 testCanDecode() { CompressionTransformFactory factory = new CompressionTransformFactory(); checkDecode(factory, "COMP", "LZMA/9", true); checkDecode(factory, "COMP", "Deflate/5", true); checkDecode(factory, "COMP", "Deflate", true); checkDecode(factory, "COMP", "", false); checkDecode(factory, "COMP", null, false); checkDecode(factory, "COMP", "BZip2/2", false); checkDecode(factory, "COMP", "GZ/9", false); checkDecode(factory, "ENC", "Deflate", false); checkDecode(factory, "SomethingCrazy", "", false); checkDecode(factory, "", "", false); checkDecode(factory, null, null, false); } |
### 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:
LZMACompressionFilter extends InputStream implements CompressionStream, Runnable { @Override public Map<String, String> getStreamMetadata() { if(!closed) { throw new IllegalStateException("Stream must be closed before getting metadata"); } Map<String,String> metadata = new HashMap<String, String>(); long compSize = compressedSize.getByteCount(); long uncompSize = uncompressedSize.getByteCount(); String compRatioString = String.format("%.1f%%", 100.0 - (compSize*100.0/uncompSize)); metadata.put(TransformConstants.META_COMPRESSION_UNCOMP_SIZE, ""+uncompSize); metadata.put(TransformConstants.META_COMPRESSION_COMP_SIZE, ""+compSize); metadata.put(TransformConstants.META_COMPRESSION_COMP_RATIO, ""+compRatioString); metadata.put(TransformConstants.META_COMPRESSION_UNCOMP_SHA1, KeyUtils.toHexPadded(digest)); return metadata; } LZMACompressionFilter(InputStream in, int compressionLevel); LZMACompressionFilter(InputStream in, LzmaProfile compressionProfile); @Override int read(); @Override int read(byte[] b); @Override int read(byte[] b, int off, int len); @Override int available(); @Override long skip(long n); @Override void close(); @Override void run(); @Override Map<String, String> getStreamMetadata(); }### Answer:
@Test public void testCompressionMetadata() throws Exception { LZMACompressionFilter lzma = runCompressMode(new LzmaProfile(16 * 1024, 128, Encoder.EMatchFinderTypeBT2)); Map<String, String> m = lzma.getStreamMetadata(); assertEquals("Uncompressed digest incorrect", "027e997e6b1dfc97b93eb28dc9a6804096d85873", m.get(TransformConstants.META_COMPRESSION_UNCOMP_SHA1)); assertEquals("Compression ratio incorrect", "93.9%", 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", 154656, Long.parseLong(m .get(TransformConstants.META_COMPRESSION_COMP_SIZE))); } |
### Question:
LZMAOutputStream extends OutputStream implements CompressionStream, Runnable { @Override public Map<String, String> getStreamMetadata() { if(!closed) { throw new IllegalStateException("Stream must be closed before getting metadata"); } Map<String,String> metadata = new HashMap<String, String>(); long compSize = compressedOutput.getByteCount(); long uncompSize = uncompressedSize.getByteCount(); String compRatioString = String.format("%.1f%%", 100.0 - (compSize*100.0/uncompSize)); metadata.put(TransformConstants.META_COMPRESSION_UNCOMP_SIZE, ""+uncompSize); metadata.put(TransformConstants.META_COMPRESSION_COMP_SIZE, ""+compSize); metadata.put(TransformConstants.META_COMPRESSION_COMP_RATIO, ""+compRatioString); metadata.put(TransformConstants.META_COMPRESSION_UNCOMP_SHA1, KeyUtils.toHexPadded(uncompressedDigest)); return metadata; } LZMAOutputStream(OutputStream out, LzmaProfile compressionProfile); LZMAOutputStream(OutputStream out, int compressionLevel); @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); @Override void run(); }### Answer:
@Test public void testCompressionMetadata() throws Exception { LZMAOutputStream lzma = runCompressMode(new LzmaProfile(16 * 1024, 128, Encoder.EMatchFinderTypeBT2)); Map<String, String> m = lzma.getStreamMetadata(); assertEquals("Uncompressed digest incorrect", "027e997e6b1dfc97b93eb28dc9a6804096d85873", m.get(TransformConstants.META_COMPRESSION_UNCOMP_SHA1)); assertEquals("Compression ratio incorrect", "93.9%", 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", 154656, 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> { @Override public BasicEncryptionOutputTransform getOutputTransform( OutputStream streamToEncodeTo, Map<String, String> metadataToEncode) throws IOException, TransformException { KeyPair asymmetricKey = getKeyPair(masterEncryptionKeyAlias); return new BasicEncryptionOutputTransform(streamToEncodeTo, metadataToEncode, masterEncryptionKeyFingerprint, asymmetricKey, encryptionTransform, keySize, provider); } 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 testGetOutputTransform() throws Exception { KeyStoreEncryptionFactory factory = new KeyStoreEncryptionFactory(keystore, keyAlias, keystorePassword.toCharArray(), provider); ByteArrayOutputStream out = new ByteArrayOutputStream(); Map<String, String> metadata = new HashMap<String, String>(); metadata.put("name1", "value1"); metadata.put("name2", "value2"); BasicEncryptionOutputTransform outTransform = factory .getOutputTransform(out, metadata); InputStream classin = this.getClass().getClassLoader() .getResourceAsStream("uncompressed.txt"); ByteArrayOutputStream classByteStream = new ByteArrayOutputStream(); byte[] buffer = new byte[4096]; int c = 0; while ((c = classin.read(buffer)) != -1) { classByteStream.write(buffer, 0, c); } byte[] uncompressedData = classByteStream.toByteArray(); classin.close(); OutputStream encryptedStream = outTransform.getEncodedOutputStream(); encryptedStream.write(uncompressedData); try { outTransform.getEncodedMetadata(); fail("Should not be able to get encoded metadata until stream is closed"); } catch (IllegalStateException e) { } encryptedStream.close(); Map<String, String> objectData = outTransform.getEncodedMetadata(); assertEquals("Uncompressed digest incorrect", "027e997e6b1dfc97b93eb28dc9a6804096d85873", objectData.get(TransformConstants.META_ENCRYPTION_UNENC_SHA1)); assertEquals("Uncompressed size incorrect", 2516125, Long.parseLong(objectData .get(TransformConstants.META_ENCRYPTION_UNENC_SIZE))); assertNotNull("Missing IV", objectData.get(TransformConstants.META_ENCRYPTION_IV)); assertEquals("Incorrect master encryption key ID", "e3a69d422e6d9008e3cdfcbea674ccd9ab4758c3", objectData.get(TransformConstants.META_ENCRYPTION_KEY_ID)); assertNotNull("Missing object key", objectData.get(TransformConstants.META_ENCRYPTION_OBJECT_KEY)); assertNotNull("Missing metadata signature", objectData.get(TransformConstants.META_ENCRYPTION_META_SIG)); assertEquals("name1 incorrect", "value1", objectData.get("name1")); assertEquals("name2 incorrect", "value2", objectData.get("name2")); String transformConfig = outTransform.getTransformConfig(); assertEquals("Transform config string incorrect", "ENC:AES/CBC/PKCS5Padding", transformConfig); logger.info("Encoded metadata: " + objectData); } |
### 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:
Injector { static <T> T instantiateTestSubject(Field f) { T testSubject; @SuppressWarnings("unchecked") Class<T> type = (Class<T>) f.getType(); if(type.isMemberClass() && !Modifier.isStatic(type.getModifiers())) { throw new AssertionError("TestSubject is an inner class. You need to instantiate '" + f.getName() + "' manually"); } Constructor<T> defaultConstructor; try { defaultConstructor = type.getDeclaredConstructor(); } catch (NoSuchMethodException e) { throw new AssertionError("TestSubject is null and has no default constructor. You need to instantiate '" + f.getName() + "' manually"); } defaultConstructor.setAccessible(true); try { testSubject = defaultConstructor.newInstance(); } catch (ReflectiveOperationException e) { throw new AssertionError("TestSubject is null and default constructor fails on invocation. You need to instantiate '" + f.getName() + "' manually", e); } return testSubject; } static void injectMocks(Object host); }### Answer:
@Test public void testInstantiateTestSubject_existingNoArg() { String actual = Injector.instantiateTestSubject(field("noArg")); assertEquals("", actual); }
@Test public void testInstantiateTestSubject_noNoArg() { AssertionError e = assertThrows(AssertionError.class, () -> Injector.instantiateTestSubject(field("noNoArg"))); assertEquals("TestSubject is null and has no default constructor. You need to instantiate 'noNoArg' manually", e.getMessage()); }
@Test public void testInstantiateTestSubject_noArgWithException() { AssertionError e = assertThrows(AssertionError.class, () -> Injector.instantiateTestSubject(field("throwingNoArgConstructor"))); assertEquals("TestSubject is null and default constructor fails on invocation. You need to instantiate 'throwingNoArgConstructor' manually", e.getMessage()); assertEquals(InvocationTargetException.class, e.getCause().getClass()); assertEquals("Test", e.getCause().getCause().getMessage()); }
@Test public void testInstantiateTestSubject_privateNoArg() { PrivateNoArgConstructor actual = Injector.instantiateTestSubject(field("privateNoArgConstructor")); assertNotNull(actual); }
@Test public void testInstantiateTestSubject_staticClass() { StaticClass actual = Injector.instantiateTestSubject(field("staticClass")); assertNotNull(actual); }
@Test public void testInstantiateTestSubject_innerClass() { AssertionError e = assertThrows(AssertionError.class, () -> Injector.instantiateTestSubject(field("innerClass"))); assertEquals("TestSubject is an inner class. You need to instantiate 'innerClass' manually", e.getMessage()); } |
### 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:
DependencyParseFeature implements FactFeature { @Override public void extractFeature(ComplexProof proof, Evidence evidence) { List<Pattern> patterns = searcher.querySolrIndex(evidence.getModel().getPropertyUri(), 20, 0, proof.getLanguage()); float score = (float) 0.0; String patternString = ""; for ( Pattern p : patterns ) { if ( p.getNormalized().trim().isEmpty() ) continue; if ( proof.getProofPhrase().toLowerCase().contains(p.getNormalized()) ) { patternString = p.getNormalized().trim(); break; } } if(!(patternString=="")) { List<TypedDependency> tdl = null; Annotation doc = evidence.getModel().corenlpClient.sentenceAnnotation(proof.getProofPhrase()); for(CoreMap sentence: doc.get(SentencesAnnotation.class)) { if(sentence.get(CoreAnnotations.TextAnnotation.class).toLowerCase().contains(patternString) && sentence.get(CoreAnnotations.TextAnnotation.class).split(" ").length<30) { List<CoreLabel> tokens = sentence.get(TokensAnnotation.class); Tree tree = parser.parse(tokens); TreebankLanguagePack tlp = new PennTreebankLanguagePack(); GrammaticalStructureFactory gsf = tlp.grammaticalStructureFactory(); GrammaticalStructure gs = gsf.newGrammaticalStructure(tree); tdl = gs.typedDependenciesEnhanced(); List<String> subLabels = new ArrayList<String>(); List<String> objLabels = new ArrayList<String>(); for (String str : proof.getSubject().split(" ")) { subLabels.add(str.toLowerCase()); } for (String str : proof.getObject().split(" ")) { objLabels.add(str.toLowerCase()); } Iterator<TypedDependency> it = tdl.iterator(); while(it.hasNext()) { TypedDependency td = it.next(); if((patternString.contains(td.gov().toString().toLowerCase()) && (subLabels.contains(td.dep().originalText().toLowerCase()))) || (patternString.contains(td.dep().toString().toLowerCase()) && (subLabels.contains(td.gov().originalText().toLowerCase())))) score = (float) (score + 0.5); if((subLabels.contains(td.dep().originalText().toLowerCase()) && (objLabels.contains(td.gov().originalText().toLowerCase()))) || (subLabels.contains(td.dep().originalText().toLowerCase()) && (objLabels.contains(td.gov().originalText().toLowerCase())))) score = (float) (score + 0.5); if((patternString.contains(td.gov().toString().toLowerCase()) && (objLabels.contains(td.dep().originalText().toLowerCase()))) || (patternString.contains(td.dep().toString().toLowerCase()) && (objLabels.contains(td.gov().originalText().toLowerCase())))) score = (float) (score + 0.5); } } } } proof.getFeatures().setValue(AbstractFactFeatures.DEPENDENCY_SUBJECT_OBJECT, score); } DependencyParseFeature(); @Override void extractFeature(ComplexProof proof, Evidence evidence); static void main(String[] args); public LexicalizedParser parser; }### Answer:
@Test public void test() { if(this.errorClass != null) { try { feature.extractFeature(this.proof, this.evidence); Assert.fail("Excpected expection"); } catch (NullPointerException e) { Assert.assertTrue(true); return; } } feature.extractFeature(this.proof, this.evidence); Assert.assertEquals(this.expectedScore, this.proof.getFeatures().value(AbstractFactFeatures.DEPENDENCY_SUBJECT_OBJECT),0.0); } |
### 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:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse exceptionHandler(Handler<Throwable> handler) { checkWritten(); this.exceptionHandler = handler; return this; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testExceptionHandler(TestContext context) { context.assertEquals(response, response.exceptionHandler(t -> { context.assertEquals("my exception", t.getMessage()); })); response.handleException(new Exception("my exception")); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse setWriteQueueMaxSize(int maxSize) { checkWritten(); return this; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testSetWriteQueueMaxSize(TestContext context) { context.assertEquals(response, response.setWriteQueueMaxSize(100)); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse drainHandler(Handler<Void> handler) { checkWritten(); return this; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testDrainHandler(TestContext context) { context.assertEquals(response, response.drainHandler(t -> { })); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public String getStatusMessage() { return statusMessage; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testGetStatusMessage(TestContext context) { context.assertEquals("OK", response.getStatusMessage()); context.assertEquals(response, response.setStatusMessage("My message")); context.assertEquals("My message", response.getStatusMessage()); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse setChunked(boolean chunked) { checkWritten(); this.chunked = chunked; return this; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testSetChunked(TestContext context) { context.assertEquals(response, response.setChunked(true)); context.assertTrue(response.isChunked()); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public MultiMap headers() { if (headers == null) { headers = MultiMap.caseInsensitiveMultiMap(); } return headers; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testHeaders(TestContext context) { MultiMap headers = response.headers(); context.assertEquals(response, response.putHeader("X-1", "value one")); context.assertEquals(response, response.putHeader("X-2", "value two")); context.assertEquals("value one", headers.get("X-1")); context.assertEquals("value two", headers.get("X-2")); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public MultiMap trailers() { if (trailers == null) { trailers = MultiMap.caseInsensitiveMultiMap(); } return trailers; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testTrailers(TestContext context) { MultiMap trailers = response.trailers(); context.assertEquals(response, response.putTrailer("X-3", "value three")); context.assertEquals(response, response.putTrailer("X-4", "value four")); context.assertEquals("value three", trailers.get("X-3")); context.assertEquals("value four", trailers.get("X-4")); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse closeHandler(Handler<Void> handler) { return this; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testCloseHandler(TestContext context) { context.assertEquals(response, response.closeHandler(v -> { })); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse endHandler(Handler<Void> handler) { checkWritten(); this.endHandler = handler; return this; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testEndHandler(TestContext context) { StringBuilder res = new StringBuilder(); context.assertEquals(response, response.endHandler(v -> { res.append("DONE"); })); response.end(); context.assertEquals("DONE", res.toString()); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse write(String chunk, String enc) { return write(Buffer.buffer(chunk, enc)); } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test(expected = java.lang.IllegalStateException.class) public void testWriteException(TestContext context) { response.write("Some data"); }
@Test public void testWrite(TestContext context) { String data = "Some data to write"; int dataLength = data.length(); response.putHeader("Content-Length", Integer.toString(dataLength)); context.assertEquals(response, response.write("Some data")); response.end(); JsonObject output = readOuput(); context.assertTrue(output.getBoolean("isBase64Encoded")); context.assertEquals(200, output.getInteger("statusCode")); context.assertEquals(Integer.toString(dataLength), output.getJsonObject("headers").getString("Content-Length")); context.assertEquals("Some data", new String(output.getBinary("body"))); } |
### 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:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse writeContinue() { return this; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testWriteContinue(TestContext context) { context.assertEquals(response, response.writeContinue()); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public void end(String chunk) { end(Buffer.buffer(chunk)); } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testEnd(TestContext context) { String data = "End the response"; int dataLength = data.length(); response.end(data); JsonObject output = readOuput(); context.assertEquals(Integer.toString(dataLength), output.getJsonObject("headers").getString("Content-Length")); context.assertEquals(data, new String(output.getBinary("body"))); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse sendFile(String filename, long offset, long length) { throw new java.lang.UnsupportedOperationException("Not supported yet."); } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test(expected = java.lang.UnsupportedOperationException.class) public void testSendFileException1(TestContext context) { response.sendFile("X"); }
@Test(expected = java.lang.UnsupportedOperationException.class) public void testSendFileException2(TestContext context) { response.sendFile("Y", 0, 10, ar -> { }); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public void close() { closed = true; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testClose(TestContext context) { context.assertFalse(response.closed()); response.close(); context.assertTrue(response.closed()); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public boolean ended() { return written; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testEnded(TestContext context) { context.assertFalse(response.ended()); response.end(); context.assertTrue(response.ended()); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public boolean headWritten() { return headWritten; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testHeadWritten(TestContext context) { context.assertFalse(response.headWritten()); response.putHeader("Content-Length", "0"); response.write(""); context.assertTrue(response.headWritten()); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse headersEndHandler(Handler<Void> handler) { this.headersEndHandler = handler; return this; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testHeadersEndHandler(TestContext context) { StringBuilder res = new StringBuilder(); context.assertEquals(response, response.headersEndHandler(v -> { res.append("DONE"); })); response.putHeader("Content-Length", "0"); context.assertEquals("", res.toString()); response.write(""); context.assertEquals("DONE", res.toString()); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse bodyEndHandler(Handler<Void> handler) { this.bodyEndHandler = handler; return this; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testBodyEndHandler(TestContext context) { StringBuilder res = new StringBuilder(); context.assertEquals(response, response.bodyEndHandler(v -> { res.append("DONE"); })); context.assertEquals("", res.toString()); response.end(); context.assertEquals("DONE", res.toString()); } |
### 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:
HttpServerResponseImpl implements HttpServerResponse { @Override public long bytesWritten() { return body().length(); } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testBytesWritten(TestContext context) { String data = "Some response data"; int dataLength = data.length(); response.end(data); JsonObject output = readOuput(); context.assertEquals((long) dataLength, response.bytesWritten()); context.assertEquals(Integer.toString(dataLength), output.getJsonObject("headers").getString("Content-Length")); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public int streamId() { return -1; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testStreamId(TestContext context) { context.assertEquals(-1, response.streamId()); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public void reset(long code) { } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testReset(TestContext context) { response.reset(); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse push(HttpMethod method, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) { return push(method, null, path, headers, handler); } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testPush(TestContext context) { StringBuilder res = new StringBuilder(); response.push(HttpMethod.GET, "/", ar -> { res.append("DONE"); context.assertTrue(ar.failed()); }); context.assertEquals("DONE", res.toString()); } |
### Question:
HttpServerResponseImpl implements HttpServerResponse { @Override public HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload) { return this; } HttpServerResponseImpl(OutputStream output); @Override boolean writeQueueFull(); @Override HttpServerResponse exceptionHandler(Handler<Throwable> handler); @Override HttpServerResponse setWriteQueueMaxSize(int maxSize); @Override HttpServerResponse drainHandler(Handler<Void> handler); @Override int getStatusCode(); @Override HttpServerResponse setStatusCode(int statusCode); @Override String getStatusMessage(); @Override HttpServerResponse setStatusMessage(String statusMessage); @Override HttpServerResponse setChunked(boolean chunked); @Override boolean isChunked(); @Override MultiMap headers(); @Override HttpServerResponse putHeader(String name, String value); @Override HttpServerResponse putHeader(CharSequence name, CharSequence value); @Override HttpServerResponse putHeader(String name, Iterable<String> values); @Override HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values); @Override MultiMap trailers(); @Override HttpServerResponse putTrailer(String name, String value); @Override HttpServerResponse putTrailer(CharSequence name, CharSequence value); @Override HttpServerResponse putTrailer(String name, Iterable<String> values); @Override HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value); @Override HttpServerResponse closeHandler(Handler<Void> handler); @Override HttpServerResponse endHandler(Handler<Void> handler); @Override HttpServerResponse write(String chunk, String enc); @Override HttpServerResponse write(String chunk); @Override HttpServerResponse write(Buffer data); @Override HttpServerResponse writeContinue(); @Override void end(String chunk); @Override void end(String chunk, String enc); @Override void end(Buffer chunk); @Override void end(); @Override HttpServerResponse sendFile(String filename, long offset, long length); @Override HttpServerResponse sendFile(String filename, long offset, long length,
Handler<AsyncResult<Void>> resultHandler); @Override void close(); @Override boolean ended(); @Override boolean closed(); @Override boolean headWritten(); @Override HttpServerResponse headersEndHandler(Handler<Void> handler); @Override HttpServerResponse bodyEndHandler(Handler<Void> handler); @Override long bytesWritten(); @Override int streamId(); @Override void reset(long code); @Override HttpServerResponse push(HttpMethod method, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(io.vertx.core.http.HttpMethod method, String host, String path,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String path, Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers,
Handler<AsyncResult<HttpServerResponse>> handler); @Override HttpServerResponse writeCustomFrame(int type, int flags, Buffer payload); }### Answer:
@Test public void testWriteCustomFrame(TestContext context) { context.assertEquals(response, response.writeCustomFrame(0, 0, Buffer.buffer())); } |
### 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()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.