method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
EndpointDiscovery { public Optional<String> discover() throws IOException { List<DiscoveryResult> discoveryResults = discoverApiUrls(apiUrls()); return discoveryResults .stream() .sorted(Comparator.comparingLong(o -> o.duration)) .map(DiscoveryResult::getEndpoint) .findFirst(); } EndpointDiscovery(@NonNull final String myUserAgent); Optional<String> discover(); }### Answer:
@Test public void discover(@Mocked Client clientMock, @Mocked ClientBuilder clientBuilderMock, @Mocked WebTarget webTargetMock, @Mocked InetAddress inetAddressMock) throws IOException { new Expectations() {{ ClientBuilder.newBuilder(); result = clientBuilderMock; clientBuilderMock.build(); result = clientMock; clientMock.target("https: InetAddress.getAllByName(EndpointDiscovery.DNS_API_ADDRESS); result = new InetAddress[] {inetAddressMock}; inetAddressMock.getCanonicalHostName(); result = "127.0.0.1"; }}; Optional<String> name = endpointDiscovery.discover(); assertThat(name.isPresent(), is(true)); } |
### Question:
EndpointDiscovery { Stats getStats(final String endpoint, final int timeout) { if (timeout <= 0) { throw new IllegalArgumentException( "timeout must be > 0, but is " + timeout); } Client client = ClientBuilder.newBuilder() .register(JacksonFeature.class) .build(); client.property(ClientProperties.CONNECT_TIMEOUT, timeout); client.property(ClientProperties.READ_TIMEOUT, timeout); WebTarget webTarget = client.target(endpoint); return webTarget.path("json/stats") .request(MediaType.APPLICATION_JSON_TYPE) .accept(MediaType.APPLICATION_JSON_TYPE) .header("User-Agent", userAgent) .get(Stats.class); } EndpointDiscovery(@NonNull final String myUserAgent); Optional<String> discover(); }### Answer:
@Test public void getStats(@Mocked Client clientMock, @Mocked ClientBuilder clientBuilderMock, @Mocked WebTarget webTargetMock, @Mocked Invocation.Builder invocationBuilderMock) { Stats myStats = new Stats(); new Expectations() {{ ClientBuilder.newBuilder(); result = clientBuilderMock; clientBuilderMock.build(); result = clientMock; clientMock.target(RadioBrowser.DEFAULT_API_URL); result = webTargetMock; invocationBuilderMock.get(Stats.class); result = myStats; }}; Stats stats = endpointDiscovery.getStats(RadioBrowser.DEFAULT_API_URL, 5000); assertThat(stats, is(myStats)); } |
### Question:
RadioBrowser { public Map<String, Integer> listCountries() { return retrieveValueStationCountList("json/countries"); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listCountries() { Map<String, Integer> countries = browser.listCountries(); assertThat(countries, notNullValue()); assertThat(countries.size(), is(not(0))); assertThat(countries.get("Germany"), is(not(0))); } |
### Question:
RadioBrowser { public Map<String, Integer> listCodecs() { return retrieveValueStationCountList("json/codecs"); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listCodecs() { Map<String, Integer> codecs = browser.listCodecs(); assertThat(codecs, notNullValue()); assertThat(codecs.size(), is(not(0))); assertThat(codecs.containsKey("AAC"), is(true)); } |
### Question:
RadioBrowser { public Map<String, Integer> listLanguages() { return retrieveValueStationCountList("json/languages"); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listLanguages() { Map<String, Integer> languages = browser.listLanguages(); assertThat(languages, notNullValue()); assertThat(languages.size(), is(not(0))); assertThat(languages.containsKey("german"), is(true)); } |
### Question:
RadioBrowser { public Map<String, Integer> listTags() { return retrieveValueStationCountList("json/tags"); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listTags() { Map<String, Integer> tags = browser.listTags(); assertThat(tags, notNullValue()); assertThat(tags.size(), is(not(0))); assertThat(tags.containsKey("80s"), is(true)); } |
### Question:
RadioBrowser { public List<Station> listStations(@NonNull final Paging paging, final ListParameter...listParam) { return listStationsPathWithPaging(Optional.of(paging), "json/stations", listParam); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listStations() { List<Station> firstStations = browser.listStations(FIRST_FIVE); assertThat(firstStations, notNullValue()); assertThat(firstStations.size(), is(FIRST_FIVE.getLimit())); List<Station> secondStations = browser.listStations(SECOND_FIVE); assertThat(secondStations, notNullValue()); assertThat(secondStations.size(), is(SECOND_FIVE.getLimit())); assertThat(firstStations, is(not(secondStations))); }
@Test public void listStationsWithStream() { List<Station> stations = browser .listStations() .limit(256) .collect(Collectors.toList()); assertThat(stations, notNullValue()); assertThat(stations, is(not(Collections.emptyList()))); assertThat(stations.size(), is(256)); }
@Test public void listStationsWithStreamAndOrder() { List<Station> stations = browser .listStations(ListParameter.create().order(FieldName.LASTCHECKTIME)) .limit(256) .collect(Collectors.toList()); assertThat(stations.size(), is(256)); Station last = null; for (Station station : stations) { if (station.getLastchecktime() != null && last != null && last.getLastchecktime() != null) { assertThat("station list must contain lastchecktime in ascending order", station.getLastchecktime().getTime(), is(Matchers.greaterThanOrEqualTo(last.getLastchecktime().getTime()))); } last = station; } }
@Test public void listStationsWithFullStream() { List<Station> stations = browser .listStations() .collect(Collectors.toList()); assertThat(stations, notNullValue()); assertThat(stations, is(not(Collections.emptyList()))); } |
### Question:
Station { @JsonGetter("tags") public String getTags() { return String.join(",", tagList); } @JsonGetter("tags") String getTags(); @JsonSetter("tags") void setTags(final String commaTags); @JsonGetter("language") String getLanguage(); @JsonSetter("language") void setLanguage(final String commaLanguages); @Override String toString(); }### Answer:
@Test public void getTagsCommaSeparated() { Station testMe = new Station(); testMe.setTagList(Arrays.asList("foo", "bar", "baz")); assertThat("foo,bar,baz", is(testMe.getTags())); } |
### Question:
RadioBrowser { public List<Station> listBrokenStations(@NonNull final Limit limit) { return listStationsPathWithLimit(Optional.of(limit), "json/stations/broken" ); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listBrokenStations() { List<Station> stations = browser.listBrokenStations(FIVE); assertThat(stations, notNullValue()); assertThat(stations.size(), is(FIVE.getSize())); }
@Test public void listBrokenStationsWithStream() { List<Station> stations = browser .listBrokenStations() .limit(256) .collect(Collectors.toList()); assertThat(stations, notNullValue()); assertThat(stations, is(not(Collections.emptyList()))); assertThat(stations.size(), is(256)); } |
### Question:
RadioBrowser { public List<Station> listTopClickStations(@NonNull final Limit limit) { return listStationsPathWithLimit(Optional.of(limit), "json/stations/topclick"); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listTopClickStations() { List<Station> stations = browser.listTopClickStations(FIVE); assertThat(stations, notNullValue()); assertThat(stations.size(), is(FIVE.getSize())); }
@Test public void listTopClickStationsWithStream() { List<Station> stations = browser .listTopClickStations() .limit(256) .collect(Collectors.toList()); assertThat(stations, notNullValue()); assertThat(stations, is(not(Collections.emptyList()))); assertThat(stations.size(), is(256)); } |
### Question:
RadioBrowser { public List<Station> listTopVoteStations(@NonNull final Limit limit) { return listStationsPathWithLimit(Optional.of(limit), "json/stations/topvote"); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listTopVoteStations() { List<Station> stations = browser.listTopVoteStations(FIVE); assertThat(stations, notNullValue()); assertThat(stations.size(), is(FIVE.getSize())); }
@Test public void listTopVoteStationsWithStream() { List<Station> stations = browser .listTopVoteStations() .limit(256) .collect(Collectors.toList()); assertThat(stations, notNullValue()); assertThat(stations, is(not(Collections.emptyList()))); assertThat(stations.size(), is(256)); } |
### Question:
RadioBrowser { public List<Station> listLastClickStations(@NonNull final Limit limit) { return listStationsPathWithLimit(Optional.of(limit), "json/stations/lastclick"); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listLastClickStations() { List<Station> stations = browser.listLastClickStations(FIVE); assertThat(stations, notNullValue()); assertThat(stations.size(), is(FIVE.getSize())); }
@Test public void listLastClickStationsWithStream() { List<Station> stations = browser .listLastClickStations() .limit(256) .collect(Collectors.toList()); assertThat(stations, notNullValue()); assertThat(stations, is(not(Collections.emptyList()))); assertThat(stations.size(), is(256)); } |
### Question:
RadioBrowser { public List<Station> listLastChangedStations(@NonNull final Limit limit) { return listStationsPathWithLimit(Optional.of(limit), "json/stations/lastchange"); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listLastChangedStations() { List<Station> stations = browser.listLastChangedStations(FIVE); assertThat(stations, notNullValue()); assertThat(stations.size(), is(FIRST_FIVE.getLimit())); }
@Test public void listLastChangedStationsWithStream() { List<Station> stations = browser .listLastChangedStations() .limit(256) .collect(Collectors.toList()); assertThat(stations, notNullValue()); assertThat(stations, is(not(Collections.emptyList()))); assertThat(stations.size(), is(256)); } |
### Question:
ListParameter { public static ListParameter create() { return new ListParameter(); } private ListParameter(); static ListParameter create(); ListParameter order(@NonNull final FieldName fieldName); ListParameter reverseOrder(final boolean reverse); }### Answer:
@Test public void create() { ListParameter listParameter = ListParameter.create(); assertThat(listParameter, is(not(nullValue()))); } |
### Question:
RadioBrowser { public Optional<Station> getStationByUUID(@NonNull final UUID uuid) { List<Station> stationList = listStationsBy( Paging.at(0, 1), SearchMode.BYUUID, uuid.toString()); if (stationList.isEmpty()) { return Optional.empty(); } else { return Optional.of(stationList.get(0)); } } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void getStationByUUID() { List<Station> stations = browser.listStations(FIRST_FIVE); Station first = stations.get(0); Optional<Station> station = browser.getStationByUUID(first.getStationUUID()); assertThat(station.isPresent(), is(true)); assertThat(station.get(), is(first)); } |
### Question:
RadioBrowser { public List<Station> listImprovableStations(@NonNull final Limit limit) { return listStationsPathWithLimit(Optional.of(limit), "json/stations/improvable"); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listImprovableStations() { List<Station> stations = browser.listImprovableStations(FIVE); assertThat(stations, notNullValue()); assertThat(stations.size(), is(FIVE.getSize())); }
@Test public void listImprovableStationsWithStream() { List<Station> stations = browser .listImprovableStations() .limit(256) .collect(Collectors.toList()); assertThat(stations, notNullValue()); assertThat(stations, is(not(Collections.emptyList()))); assertThat(stations.size(), is(256)); } |
### Question:
RadioBrowser { public List<Station> listStationsBy(@NonNull final Paging paging, @NonNull final SearchMode searchMode, @NonNull final String searchTerm, final ListParameter...listParam) { MultivaluedMap<String, String> requestParams = new MultivaluedHashMap<>(); applyPaging(paging, requestParams); Arrays.stream(listParam).forEach(l -> l.applyTo(requestParams)); Entity<Form> entity = Entity.form(requestParams); Response response = null; try { response = builder(webTarget .path("json/stations") .path(searchMode.name().toLowerCase()) .path(searchTerm)) .post(entity); checkResponseStatus(response); return response.readEntity(new GenericType<List<Station>>() { }); } finally { close(response); } } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void listStationsByWithName() { List<Station> stations = browser.listStationsBy(FIRST_FIVE, SearchMode.BYNAME, "synthradio"); assertThat(stations, notNullValue()); assertThat(stations.size(), is(1)); assertThat(stations.get(0).getUrl(), is("http: }
@Test public void listStationsBy() { List<Station> stations = browser.listStationsBy(FIRST_FIVE, SearchMode.BYNAME, "ding"); assertThat(stations, notNullValue()); assertThat(stations.size(), is(FIRST_FIVE.getLimit())); assertThat(stations.get(0).getName().toLowerCase(), containsString("ding")); }
@Test public void listStationsByWithStream() { List<Station> stations = browser .listStationsBy(SearchMode.BYNAME, "pop") .limit(256) .collect(Collectors.toList()); assertThat(stations, notNullValue()); assertThat(stations, is(not(Collections.emptyList()))); } |
### Question:
RadioBrowser { public URL resolveStreamUrl(@NonNull final UUID stationUUID) { Response response = null; try { response = builder(webTarget.path("v2/json/url") .path(stationUUID.toString())) .get(); checkResponseStatus(response); log.debug("URI is {}", webTarget.getUri()); try { UrlResponse urlResponse = response.readEntity( UrlResponse.class); if (!urlResponse.isOk()) { throw new RadioBrowserException(urlResponse.getMessage()); } return new URL(urlResponse.getUrl()); } catch (MalformedURLException e) { throw new RadioBrowserException(e); } } finally { close(response); } } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Test public void resolveStreamUrl() throws MalformedURLException { List<Station> stations = browser.listStationsBy(FIRST_FIVE, SearchMode.BYNAME, "synthradio"); URL response = browser.resolveStreamUrl(stations.get(0).getStationUUID()); assertThat(response, notNullValue()); assertThat(response, is(new URL("http: } |
### Question:
RadioBrowser { public UUID postNewStation(@NonNull final Station station) { return postNewOrEditStation(station, "json/add"); } RadioBrowser(@NonNull final String apiUrl,
final int timeout,
@NonNull final String myUserAgent); RadioBrowser(final int timeout,
final String myUserAgent); Map<String, Integer> listCountries(); Map<String, Integer> listCodecs(); Map<String, Integer> listLanguages(); Map<String, Integer> listTags(); List<Station> listStations(@NonNull final Paging paging,
final ListParameter...listParam); Stream<Station> listStations(final ListParameter...listParam); List<Station> listBrokenStations(@NonNull final Limit limit); Stream<Station> listBrokenStations(); List<Station> listImprovableStations(@NonNull final Limit limit); Stream<Station> listImprovableStations(); List<Station> listTopClickStations(@NonNull final Limit limit); Stream<Station> listTopClickStations(); List<Station> listTopVoteStations(@NonNull final Limit limit); Stream<Station> listTopVoteStations(); List<Station> listLastClickStations(@NonNull final Limit limit); Stream<Station> listLastClickStations(); List<Station> listLastChangedStations(@NonNull final Limit limit); Stream<Station> listLastChangedStations(); Optional<Station> getStationByUUID(@NonNull final UUID uuid); List<Station> listStationsBy(@NonNull final Paging paging,
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); Stream<Station> listStationsBy(
@NonNull final SearchMode searchMode,
@NonNull final String searchTerm,
final ListParameter...listParam); URL resolveStreamUrl(@NonNull final UUID stationUUID); UUID postNewStation(@NonNull final Station station); void voteForStation(@NonNull final UUID stationUUID); }### Answer:
@Ignore @Test(expected = RadioBrowserException.class) public void postNewWithFail() { Station station = new Station(); station.setHomepage("https: station.setName(TEST_NAME); station.setFavicon("https: browser.postNewStation(station); }
@Test public void postNewWithSuccess() { Station station = new Station(); station.setUrl("https: station.setHomepage("https: station.setName(TEST_NAME); station.setFavicon("https: UUID id = browser.postNewStation(station); assertThat(id, is(not(nullValue()))); } |
### Question:
PagingSpliterator extends Spliterators.AbstractSpliterator<T> { PagingSpliterator(final Function<Paging, List<T>> fetchPageFunction) { super(Long.MAX_VALUE, 0); currentPage = Paging.at(0, FETCH_SIZE_DEFAULT); this.fetchPage = fetchPageFunction; loadPage(); } PagingSpliterator(final Function<Paging, List<T>> fetchPageFunction); @Override boolean tryAdvance(final Consumer<? super T> action); }### Answer:
@Test public void testPagingSpliterator() { PagingSpliterator<Integer> integerPagingSpliterator = new PagingSpliterator<>( paging -> { List<Integer> data; if (paging.getOffset() < 100) { data = IntStream.range(paging.getOffset(), paging.getOffset() + paging.getLimit()) .boxed() .collect(Collectors.toList()); if (data.size() > paging.getLimit()) { throw new IllegalStateException(); } } else { data = Collections.emptyList(); } return data; } ); List<Integer> actual = StreamSupport.stream(integerPagingSpliterator, false) .collect(Collectors.toList()); List<Integer> expected = IntStream.range(0, 128) .boxed() .collect(Collectors.toList()); assertThat(actual, is(expected)); } |
### Question:
Paging { public static Paging at(final int offset, final int limit) { return new Paging(offset, limit); } private Paging(final int myOffset, final int myLimit); static Paging at(final int offset, final int limit); Paging previous(); Paging next(); static final Paging DEFAULT_START; }### Answer:
@Test public void at() { Paging paging = Paging.at(0, 1); assertThat(paging.getOffset(), is(0)); assertThat(paging.getLimit(), is(1)); }
@Test(expected = IllegalArgumentException.class) public void atWithZeroLimit() { Paging.at(0, 0); }
@Test(expected = IllegalArgumentException.class) public void atWithNegativeOffset() { Paging.at(-1, 1); } |
### Question:
Paging { public Paging next() { return new Paging(offset + limit, limit); } private Paging(final int myOffset, final int myLimit); static Paging at(final int offset, final int limit); Paging previous(); Paging next(); static final Paging DEFAULT_START; }### Answer:
@Test public void next() { Paging pagingFirst = Paging.at(0, 64); Paging next = pagingFirst.next(); assertThat(next.getOffset(), is(64)); assertThat(next.getLimit(), is(64)); } |
### Question:
Paging { public Paging previous() { int newOffset = offset - limit; if (newOffset < 0) { newOffset = 0; } return new Paging(newOffset, limit); } private Paging(final int myOffset, final int myLimit); static Paging at(final int offset, final int limit); Paging previous(); Paging next(); static final Paging DEFAULT_START; }### Answer:
@Test public void previous() { Paging pagingFirst = Paging.at(64, 32); Paging next = pagingFirst.previous(); assertThat(next.getOffset(), is(64 - 32 )); assertThat(next.getLimit(), is(32)); } |
### Question:
EndpointDiscovery { List<String> apiUrls() throws UnknownHostException { InetAddress[] addresses = InetAddress.getAllByName(DNS_API_ADDRESS); List<String> fqdns = new ArrayList<>(); for (InetAddress inetAddress : addresses) { fqdns.add(inetAddress.getCanonicalHostName()); } return fqdns.stream() .map(s -> String.format("https: .collect(Collectors.toList()); } EndpointDiscovery(@NonNull final String myUserAgent); Optional<String> discover(); }### Answer:
@Test public void apiUrls(@Mocked InetAddress inetAddressMock) throws UnknownHostException { InetAddress[] inetAddresses = new InetAddress[1]; inetAddresses[0] = inetAddressMock; new Expectations() {{ InetAddress.getAllByName(EndpointDiscovery.DNS_API_ADDRESS); result = inetAddresses; inetAddressMock.getCanonicalHostName(); result = "127.0.0.1"; }}; List<String> urls = endpointDiscovery.apiUrls(); assertThat(urls, is(Collections.singletonList("https: new Verifications() {{ InetAddress.getAllByName(EndpointDiscovery.DNS_API_ADDRESS); times = 1; }}; } |
### Question:
EndpointDiscovery { List<DiscoveryResult> discoverApiUrls(final List<String> apiUrls) { ExecutorService executorService = Executors.newFixedThreadPool(DEFAULT_THREADS); try { List<Future<DiscoveryResult>> futureList = new ArrayList<>(); for (final String apiUrl : apiUrls) { Callable<DiscoveryResult> discoveryResultCallable = () -> { long start = System.currentTimeMillis(); log.debug("Starting check for {}", apiUrl); Stats stats = getStats(apiUrl, DEFAULT_TIMEOUT_MILLIS); long duration = System.currentTimeMillis() - start; log.debug("Finished check for {}, took {} ms", apiUrl, duration); return new DiscoveryResult(apiUrl, duration, stats); }; futureList.add(executorService.submit(discoveryResultCallable)); } List<DiscoveryResult> discoveryResults = new ArrayList<>(); for (Future<DiscoveryResult> future : futureList) { try { DiscoveryResult discoveryResult = future.get( DEFAULT_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS); discoveryResults.add(discoveryResult); } catch (ExecutionException | TimeoutException | InterruptedException e) { log.warn("Endpoint " + (apiUrls.get(futureList.indexOf(future))) + " had an exception", e); } } return discoveryResults; } finally { executorService.shutdown(); } } EndpointDiscovery(@NonNull final String myUserAgent); Optional<String> discover(); }### Answer:
@Test public void discoverApiUrls(@Mocked Client clientMock, @Mocked ClientBuilder clientBuilderMock, @Mocked WebTarget webTargetMock) { new Expectations() {{ ClientBuilder.newBuilder(); result = clientBuilderMock; clientBuilderMock.build(); result = clientMock; clientMock.target("https: }}; List<EndpointDiscovery.DiscoveryResult> results = endpointDiscovery.discoverApiUrls(Collections.singletonList("https: assertThat(results.size(), is(1)); assertThat(results.get(0).getDuration(), is(Matchers.greaterThan(0L))); new Verifications() {{ clientMock.target("https: }}; } |
### Question:
RevisionNameSerializer extends AbstractElementSerializer<RevisionName> { private RevisionNameSerializer() { super( RevisionNameComparator.INSTANCE ); } private RevisionNameSerializer(); RevisionName fromBytes( byte[] in ); RevisionName fromBytes( byte[] in, int start ); @Override byte[] serialize( RevisionName revisionName ); @Override RevisionName deserialize( BufferHandler bufferHandler ); @Override RevisionName deserialize( ByteBuffer buffer ); }### Answer:
@Test public void testRevisionNameSerializer() throws IOException { RevisionName value = null; try { serializer.serialize( value ); fail(); } catch ( Exception e ) { } value = new RevisionName( 1L, null ); byte[] result = serializer.serialize( value ); assertEquals( 12, result.length ); assertEquals( 1L, ( long ) LongSerializer.deserialize( result ) ); assertNull( StringSerializer.deserialize( result, 8 ) ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ) ); value = new RevisionName( 0L, "" ); result = serializer.serialize( value ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ) ); value = new RevisionName( 0L, "L\u00E9charny" ); result = serializer.serialize( value ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ) ); } |
### Question:
InMemoryLeaf extends AbstractPage<K, V> { public InsertResult<K, V> insert( K key, V value, long revision ) throws IOException { int pos = findPos( key ); if ( pos < 0 ) { int index = -( pos + 1 ); InsertResult<K, V> result = replaceElement( revision, key, value, index ); return result; } if ( nbElems < btree.getPageSize() ) { Page<K, V> modifiedPage = addElement( revision, key, value, pos ); InsertResult<K, V> result = new ModifyResult<K, V>( modifiedPage, null ); result.addCopiedPage( this ); return result; } else { InsertResult<K, V> result = addAndSplit( revision, key, value, pos ); result.addCopiedPage( this ); return result; } } InMemoryLeaf( BTree<K, V> btree ); @SuppressWarnings("unchecked") InMemoryLeaf( BTree<K, V> btree, long revision, int nbElems ); InsertResult<K, V> insert( K key, V value, long revision ); V get( K key ); @Override ValueCursor<V> getValues( K key ); boolean hasKey( K key ); @Override boolean contains( K key, V value ); TupleCursor<K, V> browse( K key, ReadTransaction<K, V> transaction, ParentPos<K, V>[] stack, int depth ); TupleCursor<K, V> browse( ReadTransaction<K, V> transaction, ParentPos<K, V>[] stack, int depth ); KeyCursor<K> browseKeys( ReadTransaction<K, K> transaction, ParentPos<K, K>[] stack, int depth ); Tuple<K, V> findLeftMost(); Tuple<K, V> findRightMost(); boolean isLeaf(); boolean isNode(); String toString(); String dumpPage( String tabs ); }### Answer:
@Test public void testFindPos() throws Exception { InMemoryLeaf<Long, String> leaf = new InMemoryLeaf<Long, String>( btree ); for ( long i = 0; i < 8; i++ ) { long value = i + i + 1; leaf = ( InMemoryLeaf<Long, String> ) ( ( ModifyResult<Long, String> ) leaf.insert( value, "V" + value, 0L ) ) .getModifiedPage(); } for ( long i = 0; i < 17; i++ ) { if ( i % 2 == 1 ) { assertEquals( -( i / 2 + 1 ), leaf.findPos( i ) ); } else { assertEquals( i / 2, leaf.findPos( i ) ); } } } |
### Question:
CharSerializer extends AbstractElementSerializer<Character> { private CharSerializer() { super( CharComparator.INSTANCE ); } private CharSerializer(); byte[] serialize( Character element ); static byte[] serialize( char value ); static byte[] serialize( byte[] buffer, int start, char value ); static Character deserialize( byte[] in ); static Character deserialize( byte[] in, int start ); Character fromBytes( byte[] in ); Character fromBytes( byte[] in, int start ); Character deserialize( ByteBuffer buffer ); Character deserialize( BufferHandler bufferHandler ); static final CharSerializer INSTANCE; }### Answer:
@Test public void testCharSerializer() throws IOException { char value = 0x0000; byte[] result = CharSerializer.serialize( value ); assertEquals( ( byte ) 0x00, result[1] ); assertEquals( ( byte ) 0x00, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).charValue() ); value = 0x0001; result = CharSerializer.serialize( value ); assertEquals( ( byte ) 0x01, result[1] ); assertEquals( ( byte ) 0x00, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).charValue() ); value = 0x00FF; result = CharSerializer.serialize( value ); assertEquals( ( byte ) 0xFF, result[1] ); assertEquals( ( byte ) 0x00, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).charValue() ); value = 0x0100; result = CharSerializer.serialize( value ); assertEquals( ( byte ) 0x00, result[1] ); assertEquals( ( byte ) 0x01, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).charValue() ); value = 0x7FFF; result = CharSerializer.serialize( value ); assertEquals( ( byte ) 0xFF, result[1] ); assertEquals( ( byte ) 0x7F, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).charValue() ); value = 0x8000; result = CharSerializer.serialize( value ); assertEquals( ( byte ) 0x00, result[1] ); assertEquals( ( byte ) 0x80, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).charValue() ); value = 0xFFFF; result = CharSerializer.serialize( value ); assertEquals( ( byte ) 0xFF, result[1] ); assertEquals( ( byte ) 0xFF, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).charValue() ); } |
### Question:
ShortSerializer extends AbstractElementSerializer<Short> { private ShortSerializer() { super( ShortComparator.INSTANCE ); } private ShortSerializer(); byte[] serialize( Short element ); static byte[] serialize( short value ); static byte[] serialize( byte[] buffer, int start, short value ); static Short deserialize( byte[] in ); static Short deserialize( byte[] in, int start ); Short fromBytes( byte[] in ); Short fromBytes( byte[] in, int start ); Short deserialize( ByteBuffer buffer ); Short deserialize( BufferHandler bufferHandler ); final static ShortSerializer INSTANCE; }### Answer:
@Test public void testShortSerializer() throws IOException { short value = 0x0000; byte[] result = ShortSerializer.serialize( value ); assertEquals( ( byte ) 0x00, result[1] ); assertEquals( ( byte ) 0x00, result[0] ); assertEquals( value, ShortSerializer.INSTANCE.deserialize( new BufferHandler( result ) ).shortValue() ); value = 0x0001; result = ShortSerializer.serialize( value ); assertEquals( ( byte ) 0x01, result[1] ); assertEquals( ( byte ) 0x00, result[0] ); assertEquals( value, ShortSerializer.INSTANCE.deserialize( new BufferHandler( result ) ).shortValue() ); value = 0x00FF; result = ShortSerializer.serialize( value ); assertEquals( ( byte ) 0xFF, result[1] ); assertEquals( ( byte ) 0x00, result[0] ); assertEquals( value, ShortSerializer.INSTANCE.deserialize( new BufferHandler( result ) ).shortValue() ); value = 0x0100; result = ShortSerializer.serialize( value ); assertEquals( ( byte ) 0x00, result[1] ); assertEquals( ( byte ) 0x01, result[0] ); assertEquals( value, ShortSerializer.INSTANCE.deserialize( new BufferHandler( result ) ).shortValue() ); value = 0x7FFF; result = ShortSerializer.serialize( value ); assertEquals( ( byte ) 0xFF, result[1] ); assertEquals( ( byte ) 0x7F, result[0] ); assertEquals( value, ShortSerializer.INSTANCE.deserialize( new BufferHandler( result ) ).shortValue() ); value = ( short ) 0x8000; result = ShortSerializer.serialize( value ); assertEquals( ( byte ) 0x00, result[1] ); assertEquals( ( byte ) 0x80, result[0] ); assertEquals( value, ShortSerializer.INSTANCE.deserialize( new BufferHandler( result ) ).shortValue() ); value = ( short ) 0xFFFF; result = ShortSerializer.serialize( value ); assertEquals( ( byte ) 0xFF, result[1] ); assertEquals( ( byte ) 0xFF, result[0] ); assertEquals( value, ShortSerializer.INSTANCE.deserialize( new BufferHandler( result ) ).shortValue() ); } |
### Question:
BooleanSerializer extends AbstractElementSerializer<Boolean> { private BooleanSerializer() { super( BooleanComparator.INSTANCE ); } private BooleanSerializer(); byte[] serialize( Boolean element ); static byte[] serialize( boolean element ); static byte[] serialize( byte[] buffer, int start, boolean element ); static Boolean deserialize( byte[] in ); static Boolean deserialize( byte[] in, int start ); Boolean fromBytes( byte[] in ); Boolean fromBytes( byte[] in, int start ); Boolean deserialize( ByteBuffer buffer ); @Override Boolean deserialize( BufferHandler bufferHandler ); static final BooleanSerializer INSTANCE; }### Answer:
@Test public void testBooleanSerializer() throws IOException { boolean value = true; byte[] result = BooleanSerializer.serialize( value ); assertEquals( ( byte ) 0x01, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).booleanValue() ); value = false; result = BooleanSerializer.serialize( value ); assertEquals( ( byte ) 0x00, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).booleanValue() ); } |
### Question:
StringSerializer extends AbstractElementSerializer<String> { private StringSerializer() { super( StringComparator.INSTANCE ); } private StringSerializer(); StringSerializer( Comparator<String> comparator ); static String deserialize( byte[] in ); static String deserialize( byte[] in, int start ); String fromBytes( byte[] in ); String fromBytes( byte[] in, int start ); static byte[] serialize( byte[] buffer, int start, String element ); byte[] serialize( String element ); String deserialize( BufferHandler bufferHandler ); String deserialize( ByteBuffer buffer ); @Override int compare( String type1, String type2 ); static final StringSerializer INSTANCE; }### Answer:
@Test public void testStringSerializer() throws IOException { String value = null; byte[] result = serializer.serialize( value ); assertEquals( 4, result.length ); assertEquals( ( byte ) 0xFF, result[0] ); assertEquals( ( byte ) 0xFF, result[1] ); assertEquals( ( byte ) 0xFF, result[2] ); assertEquals( ( byte ) 0xFF, result[3] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ) ); value = ""; result = serializer.serialize( value ); assertEquals( 4, result.length ); assertEquals( ( byte ) 0x00, result[0] ); assertEquals( ( byte ) 0x00, result[1] ); assertEquals( ( byte ) 0x00, result[2] ); assertEquals( ( byte ) 0x00, result[3] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ) ); value = "test"; result = serializer.serialize( value ); assertEquals( 8, result.length ); assertEquals( ( byte ) 0x00, result[0] ); assertEquals( ( byte ) 0x00, result[1] ); assertEquals( ( byte ) 0x00, result[2] ); assertEquals( ( byte ) 0x04, result[3] ); assertEquals( 't', result[4] ); assertEquals( 'e', result[5] ); assertEquals( 's', result[6] ); assertEquals( 't', result[7] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ) ); value = "L\u00E9charny"; result = serializer.serialize( value ); assertEquals( 13, result.length ); assertEquals( ( byte ) 0x00, result[0] ); assertEquals( ( byte ) 0x00, result[1] ); assertEquals( ( byte ) 0x00, result[2] ); assertEquals( ( byte ) 0x09, result[3] ); assertEquals( 'L', result[4] ); assertEquals( ( byte ) 0xC3, result[5] ); assertEquals( ( byte ) 0xA9, result[6] ); assertEquals( 'c', result[7] ); assertEquals( 'h', result[8] ); assertEquals( 'a', result[9] ); assertEquals( 'r', result[10] ); assertEquals( 'n', result[11] ); assertEquals( 'y', result[12] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ) ); } |
### Question:
ByteSerializer extends AbstractElementSerializer<Byte> { private ByteSerializer() { super( ByteComparator.INSTANCE ); } private ByteSerializer(); byte[] serialize( Byte element ); static byte[] serialize( byte value ); static byte[] serialize( byte[] buffer, int start, byte value ); static Byte deserialize( byte[] in ); static Byte deserialize( byte[] in, int start ); Byte fromBytes( byte[] in ); Byte fromBytes( byte[] in, int start ); Byte deserialize( ByteBuffer buffer ); Byte deserialize( BufferHandler bufferHandler ); static final ByteSerializer INSTANCE; }### Answer:
@Test public void testByteSerializer() throws IOException { byte value = 0x00; byte[] result = ByteSerializer.serialize( value ); assertEquals( ( byte ) 0x00, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).byteValue() ); value = 0x01; result = ByteSerializer.serialize( value ); assertEquals( ( byte ) 0x01, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).byteValue() ); value = 0x7F; result = ByteSerializer.serialize( value ); assertEquals( ( byte ) 0x7F, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).byteValue() ); value = ( byte ) 0x80; result = ByteSerializer.serialize( value ); assertEquals( ( byte ) 0x80, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).byteValue() ); value = ( byte ) 0xFF; result = ByteSerializer.serialize( value ); assertEquals( ( byte ) 0xFF, result[0] ); assertEquals( value, serializer.deserialize( new BufferHandler( result ) ).byteValue() ); } |
### Question:
RevisionNameComparator implements Comparator<RevisionName> { private RevisionNameComparator() { } private RevisionNameComparator(); int compare( RevisionName rn1, RevisionName rn2 ); static final RevisionNameComparator INSTANCE; }### Answer:
@Test public void testRevisionNameComparator() { RevisionNameComparator comparator = RevisionNameComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( new RevisionName( 0L, "test" ), new RevisionName( 0L, "test" ) ) ); assertEquals( 1, comparator.compare( new RevisionName( 3L, "test" ), new RevisionName( 0L, "test" ) ) ); assertEquals( -1, comparator.compare( new RevisionName( 3L, "test" ), new RevisionName( 5L, "test" ) ) ); assertEquals( 1, comparator.compare( new RevisionName( 3L, "test2" ), new RevisionName( 3L, "test1" ) ) ); assertEquals( -1, comparator.compare( new RevisionName( 3L, "test" ), new RevisionName( 3L, "test2" ) ) ); } |
### Question:
InMemoryBTree extends AbstractBTree<K, V> implements Closeable { public void close() throws IOException { if ( getType() == BTreeTypeEnum.BACKED_ON_DISK ) { flush(); journalChannel.close(); } } InMemoryBTree(); InMemoryBTree( InMemoryBTreeConfiguration<K, V> configuration ); void close(); void flush( File file ); void load( File file ); Page<K, V> getRootPage( long revision ); Page<K, V> getRootPage(); void flush(); File getFile(); void setFilePath( String filePath ); File getJournal(); boolean isInMemory(); boolean isPersistent(); String toString(); static final String DEFAULT_JOURNAL; static final String DATA_SUFFIX; static final String JOURNAL_SUFFIX; }### Answer:
@Test public void testBrowseEmptyTree() throws Exception { BTree<Integer, String> btree = BTreeFactory.createInMemoryBTree( "test", IntSerializer.INSTANCE, StringSerializer.INSTANCE ); btree.setPageSize( 8 ); TupleCursor<Integer, String> cursor = btree.browse(); assertFalse( cursor.hasNext() ); assertFalse( cursor.hasPrev() ); cursor.close(); btree.close(); }
@Test public void testExist() throws IOException, KeyNotFoundException { BTree<Integer, String> btree = createTwoLevelBTreeFullLeaves(); for ( int i = 1; i < 21; i++ ) { assertTrue( btree.hasKey( 5 ) ); } assertFalse( btree.hasKey( 0 ) ); assertFalse( btree.hasKey( 21 ) ); btree.close(); } |
### Question:
ByteArrayComparator implements Comparator<byte[]> { private ByteArrayComparator() { } private ByteArrayComparator(); int compare( byte[] byteArray1, byte[] byteArray2 ); static final ByteArrayComparator INSTANCE; }### Answer:
@Test public void testByteArrayComparator() { ByteArrayComparator comparator = ByteArrayComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( new byte[] {}, new byte[] {} ) ); assertEquals( 0, comparator.compare( new byte[] { 0x01, 0x02 }, new byte[] { 0x01, 0x02 } ) ); assertEquals( 1, comparator.compare( new byte[] {}, null ) ); assertEquals( 1, comparator.compare( new byte[] { 0x01 }, null ) ); assertEquals( 1, comparator.compare( new byte[] { 0x01, 0x02 }, new byte[] { 0x01, 0x01 } ) ); assertEquals( 1, comparator.compare( new byte[] { 0x01, 0x02, 0x01 }, new byte[] { 0x01, 0x02 } ) ); assertEquals( 1, comparator.compare( new byte[] { 0x01, 0x02 }, new byte[] { 0x01, 0x01, 0x02 } ) ); assertEquals( -1, comparator.compare( null, new byte[] {} ) ); assertEquals( -1, comparator.compare( null, new byte[] { 0x01, 0x02 } ) ); assertEquals( -1, comparator.compare( null, new byte[] { ( byte ) 0xFF, 0x02 } ) ); assertEquals( -1, comparator.compare( new byte[] {}, new byte[] { 0x01, 0x02 } ) ); assertEquals( -1, comparator.compare( new byte[] {}, new byte[] { ( byte ) 0xFF, 0x02 } ) ); assertEquals( -1, comparator.compare( new byte[] { ( byte ) 0xFF, 0x01 }, new byte[] { 0x01, 0x01, 0x02 } ) ); byte[] array = new byte[3]; array[0] = 0x01; array[1] = 0x02; assertEquals( -1, comparator.compare( new byte[] { 0x01, 0x02 }, array ) ); } |
### Question:
ShortArrayComparator implements Comparator<short[]> { private ShortArrayComparator() { } private ShortArrayComparator(); int compare( short[] shortArray1, short[] shortArray2 ); static final ShortArrayComparator INSTANCE; }### Answer:
@Test public void testShortArrayComparator() { ShortArrayComparator comparator = ShortArrayComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( new short[] {}, new short[] {} ) ); assertEquals( 0, comparator.compare( new short[] { ( short ) 1, ( short ) 2 }, new short[] { ( short ) 1, ( short ) 2 } ) ); assertEquals( 1, comparator.compare( new short[] {}, null ) ); assertEquals( 1, comparator.compare( new short[] { ( short ) 1 }, null ) ); assertEquals( 1, comparator.compare( new short[] { ( short ) 1, ( short ) 2 }, new short[] { ( short ) 1, ( short ) 1 } ) ); assertEquals( 1, comparator.compare( new short[] { ( short ) 1, ( short ) 2, ( short ) 1 }, new short[] { ( short ) 1, ( short ) 2 } ) ); assertEquals( 1, comparator.compare( new short[] { ( short ) 1, ( short ) 2 }, new short[] { ( short ) 1, ( short ) 1, ( short ) 2 } ) ); assertEquals( -1, comparator.compare( null, new short[] {} ) ); assertEquals( -1, comparator.compare( null, new short[] { ( short ) 1, ( short ) 2 } ) ); assertEquals( -1, comparator.compare( null, new short[] { ( short ) -1, ( short ) 2 } ) ); assertEquals( -1, comparator.compare( new short[] {}, new short[] { ( short ) 1, ( short ) 2 } ) ); assertEquals( -1, comparator.compare( new short[] {}, new short[] { ( short ) -1, ( short ) 2 } ) ); assertEquals( -1, comparator.compare( new short[] { ( short ) -1, ( short ) 1 }, new short[] { ( short ) 1, ( short ) 1, ( short ) 2 } ) ); short[] array = new short[3]; array[0] = ( short ) 1; array[1] = ( short ) 2; assertEquals( -1, comparator.compare( new short[] { ( short ) 1, ( short ) 2 }, array ) ); } |
### Question:
CharComparator implements Comparator<Character> { private CharComparator() { } private CharComparator(); int compare( Character char1, Character char2 ); static final CharComparator INSTANCE; }### Answer:
@Test public void testCharComparator() { CharComparator comparator = CharComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( 'a', 'a' ) ); assertEquals( 0, comparator.compare( '\u00e9', '\u00e9' ) ); assertEquals( 1, comparator.compare( 'a', null ) ); assertEquals( -1, comparator.compare( 'A', 'a' ) ); assertEquals( 1, comparator.compare( 'a', 'A' ) ); assertEquals( -1, comparator.compare( null, 'a' ) ); assertEquals( -1, comparator.compare( 'a', 'b' ) ); } |
### Question:
ShortComparator implements Comparator<Short> { private ShortComparator() { } private ShortComparator(); int compare( Short short1, Short short2 ); static final ShortComparator INSTANCE; }### Answer:
@Test public void testShortComparator() { ShortComparator comparator = ShortComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( ( short ) 1, ( short ) 1 ) ); assertEquals( 0, comparator.compare( ( short ) -1, ( short ) -1 ) ); assertEquals( 1, comparator.compare( ( short ) 1, null ) ); assertEquals( 1, comparator.compare( ( short ) 2, ( short ) 1 ) ); assertEquals( 1, comparator.compare( ( short ) 3, ( short ) 1 ) ); assertEquals( 1, comparator.compare( ( short ) 1, ( short ) -1 ) ); assertEquals( -1, comparator.compare( null, ( short ) 1 ) ); assertEquals( -1, comparator.compare( ( short ) 1, ( short ) 2 ) ); assertEquals( -1, comparator.compare( ( short ) -1, ( short ) 1 ) ); } |
### Question:
BooleanArrayComparator implements Comparator<boolean[]> { private BooleanArrayComparator() { } private BooleanArrayComparator(); int compare( boolean[] booleanArray1, boolean[] booleanArray2 ); static final BooleanArrayComparator INSTANCE; }### Answer:
@Test public void testBooleanArrayComparator() { BooleanArrayComparator comparator = BooleanArrayComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); boolean[] b1 = new boolean[] { true, true, true }; boolean[] b2 = new boolean[] { true, true, false }; boolean[] b3 = new boolean[] { true, false, true }; boolean[] b4 = new boolean[] { false, true, true }; boolean[] b5 = new boolean[] { true, true }; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( new boolean[] {}, new boolean[] {} ) ); assertEquals( 0, comparator.compare( b1, b1 ) ); assertEquals( -1, comparator.compare( null, new boolean[] {} ) ); assertEquals( -1, comparator.compare( null, b1 ) ); assertEquals( -1, comparator.compare( new boolean[] {}, b1 ) ); assertEquals( -1, comparator.compare( new boolean[] {}, b4 ) ); assertEquals( -1, comparator.compare( b5, b1 ) ); assertEquals( -1, comparator.compare( b5, b3 ) ); assertEquals( 1, comparator.compare( new boolean[] {}, null ) ); assertEquals( 1, comparator.compare( b1, null ) ); assertEquals( 1, comparator.compare( b1, new boolean[] {} ) ); assertEquals( 1, comparator.compare( b1, b2 ) ); assertEquals( 1, comparator.compare( b1, b3 ) ); assertEquals( 1, comparator.compare( b1, b4 ) ); assertEquals( 1, comparator.compare( b1, b5 ) ); } |
### Question:
CharArrayComparator implements Comparator<char[]> { private CharArrayComparator() { } private CharArrayComparator(); int compare( char[] charArray1, char[] charArray2 ); static final CharArrayComparator INSTANCE; }### Answer:
@Test public void testCharArrayComparator() { CharArrayComparator comparator = CharArrayComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( new char[] {}, new char[] {} ) ); assertEquals( 0, comparator.compare( new char[] { 'a', 'b' }, new char[] { 'a', 'b' } ) ); assertEquals( 1, comparator.compare( new char[] {}, null ) ); assertEquals( 1, comparator.compare( new char[] { 'a' }, null ) ); assertEquals( 1, comparator.compare( new char[] { 'a', 'b' }, new char[] { 'a', 'a' } ) ); assertEquals( 1, comparator.compare( new char[] { 'a', 'b', 'a' }, new char[] { 'a', 'b' } ) ); assertEquals( 1, comparator.compare( new char[] { 'a', 'b' }, new char[] { 'a', 'a', 'b' } ) ); assertEquals( -1, comparator.compare( null, new char[] {} ) ); assertEquals( -1, comparator.compare( null, new char[] { 'a', 'b' } ) ); assertEquals( -1, comparator.compare( null, new char[] { '\uffff', 'b' } ) ); assertEquals( -1, comparator.compare( new char[] {}, new char[] { 'a', 'b' } ) ); assertEquals( -1, comparator.compare( new char[] {}, new char[] { '\uffff', 'b' } ) ); assertEquals( -1, comparator.compare( new char[] { '0', 'a' }, new char[] { 'a', 'a', 'b' } ) ); char[] array = new char[3]; array[0] = 'a'; array[1] = 'b'; assertEquals( -1, comparator.compare( new char[] { 'a', 'b' }, array ) ); } |
### Question:
ByteComparator implements Comparator<Byte> { private ByteComparator() { } private ByteComparator(); int compare( Byte byte1, Byte byte2 ); static final ByteComparator INSTANCE; }### Answer:
@Test public void testByteComparator() { ByteComparator comparator = ByteComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( ( byte ) 0x00, ( byte ) 0x00 ) ); assertEquals( 0, comparator.compare( ( byte ) 0xFE, ( byte ) 0xFE ) ); assertEquals( 1, comparator.compare( ( byte ) 0x01, null ) ); assertEquals( 1, comparator.compare( ( byte ) 0x01, ( byte ) 0x00 ) ); assertEquals( 1, comparator.compare( ( byte ) 0x00, ( byte ) 0xFF ) ); assertEquals( 1, comparator.compare( ( byte ) 0x7F, ( byte ) 0x01 ) ); assertEquals( -1, comparator.compare( null, ( byte ) 0x00 ) ); assertEquals( -1, comparator.compare( null, ( byte ) 0xFF ) ); assertEquals( -1, comparator.compare( ( byte ) 0x00, ( byte ) 0x01 ) ); assertEquals( -1, comparator.compare( ( byte ) 0xF0, ( byte ) 0xFF ) ); assertEquals( -1, comparator.compare( ( byte ) 0xFF, ( byte ) 0x01 ) ); } |
### Question:
LongArrayComparator implements Comparator<long[]> { private LongArrayComparator() { } private LongArrayComparator(); int compare( long[] longArray1, long[] longArray2 ); static final LongArrayComparator INSTANCE; }### Answer:
@Test public void testLongArrayComparator() { LongArrayComparator comparator = LongArrayComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( new long[] {}, new long[] {} ) ); assertEquals( 0, comparator.compare( new long[] { 1L, 2L }, new long[] { 1L, 2L } ) ); assertEquals( 1, comparator.compare( new long[] {}, null ) ); assertEquals( 1, comparator.compare( new long[] { 1L }, null ) ); assertEquals( 1, comparator.compare( new long[] { 1L, 2L }, new long[] { 1L, 1L } ) ); assertEquals( 1, comparator.compare( new long[] { 1L, 2L, 1L }, new long[] { 1L, 2L } ) ); assertEquals( 1, comparator.compare( new long[] { 1L, 2L }, new long[] { 1L, 1L, 2L } ) ); assertEquals( -1, comparator.compare( null, new long[] {} ) ); assertEquals( -1, comparator.compare( null, new long[] { 1L, 2L } ) ); assertEquals( -1, comparator.compare( null, new long[] { -1L, 2L } ) ); assertEquals( -1, comparator.compare( new long[] {}, new long[] { 1L, 2L } ) ); assertEquals( -1, comparator.compare( new long[] {}, new long[] { -1L, 2L } ) ); assertEquals( -1, comparator.compare( new long[] { -1L, 1L }, new long[] { 1L, 1L, 2L } ) ); long[] array = new long[3]; array[0] = 1L; array[1] = 2L; assertEquals( -1, comparator.compare( new long[] { 1L, 2L }, array ) ); } |
### Question:
LongComparator implements Comparator<Long> { private LongComparator() { } private LongComparator(); int compare( Long long1, Long long2 ); static final LongComparator INSTANCE; }### Answer:
@Test public void testLongComparator() { LongComparator comparator = LongComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( 1L, 1L ) ); assertEquals( 0, comparator.compare( -1L, -1L ) ); assertEquals( 1, comparator.compare( 1L, null ) ); assertEquals( 1, comparator.compare( 2L, 1L ) ); assertEquals( 1, comparator.compare( 3L, 1L ) ); assertEquals( 1, comparator.compare( 1L, -1L ) ); assertEquals( -1, comparator.compare( null, 1L ) ); assertEquals( -1, comparator.compare( 1L, 2L ) ); assertEquals( -1, comparator.compare( -1L, 1L ) ); } |
### Question:
IntComparator implements Comparator<Integer> { private IntComparator() { } private IntComparator(); int compare( Integer integer1, Integer integer2 ); static final IntComparator INSTANCE; }### Answer:
@Test public void testIntComparator() { IntComparator comparator = IntComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( 1, 1 ) ); assertEquals( 0, comparator.compare( -1, -1 ) ); assertEquals( 1, comparator.compare( 1, null ) ); assertEquals( 1, comparator.compare( 2, 1 ) ); assertEquals( 1, comparator.compare( 3, 1 ) ); assertEquals( 1, comparator.compare( 1, -1 ) ); assertEquals( -1, comparator.compare( null, 1 ) ); assertEquals( -1, comparator.compare( 1, 2 ) ); assertEquals( -1, comparator.compare( -1, 1 ) ); } |
### Question:
BooleanComparator implements Comparator<Boolean> { private BooleanComparator() { } private BooleanComparator(); int compare( Boolean boolean1, Boolean boolean2 ); static final BooleanComparator INSTANCE; }### Answer:
@Test public void testBooleanComparator() { BooleanComparator comparator = BooleanComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( true, true ) ); assertEquals( 0, comparator.compare( false, false ) ); assertEquals( 1, comparator.compare( false, null ) ); assertEquals( 1, comparator.compare( true, null ) ); assertEquals( 1, comparator.compare( true, false ) ); assertEquals( -1, comparator.compare( null, false ) ); assertEquals( -1, comparator.compare( null, true ) ); assertEquals( -1, comparator.compare( false, true ) ); } |
### Question:
StringComparator implements Comparator<String> { private StringComparator() { } private StringComparator(); int compare( String string1, String string2 ); static final StringComparator INSTANCE; }### Answer:
@Test public void testStringComparator() { StringComparator comparator = StringComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( "", "" ) ); assertEquals( 0, comparator.compare( "abc", "abc" ) ); assertEquals( 1, comparator.compare( "", null ) ); assertEquals( 1, comparator.compare( "abc", "" ) ); assertEquals( 1, comparator.compare( "ac", "ab" ) ); assertEquals( 1, comparator.compare( "abc", "ab" ) ); assertEquals( -1, comparator.compare( null, "" ) ); assertEquals( -1, comparator.compare( "ab", "abc" ) ); assertEquals( -1, comparator.compare( "ab", "abc" ) ); } |
### Question:
IntArrayComparator implements Comparator<int[]> { private IntArrayComparator() { } private IntArrayComparator(); int compare( int[] intArray1, int[] intArray2 ); static final IntArrayComparator INSTANCE; }### Answer:
@Test public void testIntArrayComparator() { IntArrayComparator comparator = IntArrayComparator.INSTANCE; assertEquals( 0, comparator.compare( null, null ) ); assertEquals( 0, comparator.compare( new int[] {}, new int[] {} ) ); assertEquals( 0, comparator.compare( new int[] { 1, 2 }, new int[] { 1, 2 } ) ); assertEquals( 1, comparator.compare( new int[] {}, null ) ); assertEquals( 1, comparator.compare( new int[] { 1 }, null ) ); assertEquals( 1, comparator.compare( new int[] { 1, 2 }, new int[] { 1, 1 } ) ); assertEquals( 1, comparator.compare( new int[] { 1, 2, 1 }, new int[] { 1, 2 } ) ); assertEquals( 1, comparator.compare( new int[] { 1, 2 }, new int[] { 1, 1, 2 } ) ); assertEquals( -1, comparator.compare( null, new int[] {} ) ); assertEquals( -1, comparator.compare( null, new int[] { 1, 2 } ) ); assertEquals( -1, comparator.compare( null, new int[] { -1, 2 } ) ); assertEquals( -1, comparator.compare( new int[] {}, new int[] { 1, 2 } ) ); assertEquals( -1, comparator.compare( new int[] {}, new int[] { -1, 2 } ) ); assertEquals( -1, comparator.compare( new int[] { -1, 1 }, new int[] { 1, 1, 2 } ) ); int[] array = new int[3]; array[0] = 1; array[1] = 2; assertEquals( -1, comparator.compare( new int[] { 1, 2 }, array ) ); } |
### Question:
RecordManager extends AbstractTransactionManager { public RecordManager( String fileName ) { this( fileName, DEFAULT_PAGE_SIZE ); } RecordManager( String fileName ); RecordManager( String fileName, int pageSize ); void beginTransaction(); void commit(); boolean isContextOk(); void rollback(); Page<K, V> deserialize( BTree<K, V> btree, long offset ); synchronized void manage( BTree<K, V> btree ); synchronized void manageSubBtree( BTree<K, V> btree ); void updateRecordManagerHeader(); void updateRecordManagerHeader( long newBtreeOfBtreesOffset, long newCopiedPageBtreeOffset ); int getPageSize(); void close(); static String dump( byte octet ); void dump(); int getNbManagedTrees(); Set<String> getManagedTrees(); BTree<K, V> getManagedTree( String name ); boolean isKeepRevisions(); void setKeepRevisions( boolean keepRevisions ); @SuppressWarnings("all") BTree<K, V> addBTree( String name, ElementSerializer<K> keySerializer,
ElementSerializer<V> valueSerializer, boolean allowDuplicates ); BTreeHeader getBTreeHeader( String name ); BTreeHeader getNewBTreeHeader( String name ); void updateNewBTreeHeaders( BTreeHeader btreeHeader ); String toString(); public AtomicLong nbFreedPages; public AtomicLong nbCreatedPages; public AtomicLong nbReusedPages; public AtomicLong nbUpdateRMHeader; public AtomicLong nbUpdateBtreeHeader; public AtomicLong nbUpdatePageIOs; static final long NO_PAGE; static final int DEFAULT_PAGE_SIZE; static final boolean INTERNAL_BTREE; static final boolean NORMAL_BTREE; public Map<Long, Integer> writeCounter; }### Answer:
@Test @Ignore public void testRecordManager() throws IOException, BTreeAlreadyManagedException { assertEquals( 1, recordManager.getNbManagedTrees() ); Set<String> managedBTrees = recordManager.getManagedTrees(); assertEquals( 1, managedBTrees.size() ); assertTrue( managedBTrees.contains( "test" ) ); BTree<Long, String> btree1 = recordManager.getManagedTree( "test" ); assertNotNull( btree1 ); assertEquals( btree.getKeyComparator().getClass().getName(), btree1.getKeyComparator().getClass().getName() ); assertEquals( btree.getKeySerializer().getClass().getName(), btree1.getKeySerializer().getClass().getName() ); assertEquals( btree.getName(), btree1.getName() ); assertEquals( btree.getNbElems(), btree1.getNbElems() ); assertEquals( btree.getPageSize(), btree1.getPageSize() ); assertEquals( btree.getRevision(), btree1.getRevision() ); assertEquals( btree.getValueSerializer().getClass().getName(), btree1.getValueSerializer().getClass().getName() ); } |
### Question:
RouterFunctions { public static <T extends ServerResponse> RouterFunction<T> route(RequestPredicate predicate, HandlerFunction<T> handlerFunction) { Assert.notNull(predicate, "'predicate' must not be null"); Assert.notNull(handlerFunction, "'handlerFunction' must not be null"); return new DefaultRouterFunction<>(predicate, handlerFunction); } static RouterFunction<T> route(RequestPredicate predicate,
HandlerFunction<T> handlerFunction); static RouterFunction<T> nest(RequestPredicate predicate,
RouterFunction<T> routerFunction); static RouterFunction<ServerResponse> resources(String pattern, Resource location); static RouterFunction<ServerResponse> resources(Function<ServerRequest, Mono<Resource>> lookupFunction); static HttpHandler toHttpHandler(RouterFunction<?> routerFunction); static HttpHandler toHttpHandler(RouterFunction<?> routerFunction, HandlerStrategies strategies); static WebHandler toWebHandler(RouterFunction<?> routerFunction); static WebHandler toWebHandler(RouterFunction<?> routerFunction, HandlerStrategies strategies); static final String REQUEST_ATTRIBUTE; static final String URI_TEMPLATE_VARIABLES_ATTRIBUTE; }### Answer:
@Test public void and() throws Exception { HandlerFunction<ServerResponse> handlerFunction = request -> ServerResponse.ok().build(); RouterFunction<ServerResponse> routerFunction1 = request -> Mono.empty(); RouterFunction<ServerResponse> routerFunction2 = request -> Mono.just(handlerFunction); RouterFunction<ServerResponse> result = routerFunction1.and(routerFunction2); assertNotNull(result); MockServerRequest request = MockServerRequest.builder().build(); Mono<HandlerFunction<ServerResponse>> resultHandlerFunction = result.route(request); StepVerifier.create(resultHandlerFunction) .expectNext(handlerFunction) .expectComplete() .verify(); }
@Test public void andOther() throws Exception { HandlerFunction<ServerResponse> handlerFunction = request -> ServerResponse.ok().body(fromObject("42")); RouterFunction<?> routerFunction1 = request -> Mono.empty(); RouterFunction<ServerResponse> routerFunction2 = request -> Mono.just(handlerFunction); RouterFunction<?> result = routerFunction1.andOther(routerFunction2); assertNotNull(result); MockServerRequest request = MockServerRequest.builder().build(); Mono<? extends HandlerFunction<?>> resultHandlerFunction = result.route(request); StepVerifier.create(resultHandlerFunction) .expectNextMatches(o -> o.equals(handlerFunction)) .expectComplete() .verify(); }
@Test public void andRoute() throws Exception { RouterFunction<ServerResponse> routerFunction1 = request -> Mono.empty(); RequestPredicate requestPredicate = request -> true; RouterFunction<ServerResponse> result = routerFunction1.andRoute(requestPredicate, this::handlerMethod); assertNotNull(result); MockServerRequest request = MockServerRequest.builder().build(); Mono<? extends HandlerFunction<?>> resultHandlerFunction = result.route(request); StepVerifier.create(resultHandlerFunction) .expectNextCount(1) .expectComplete() .verify(); }
@Test public void filter() throws Exception { Mono<String> stringMono = Mono.just("42"); HandlerFunction<EntityResponse<Mono<String>>> handlerFunction = request -> EntityResponse.fromPublisher(stringMono, String.class).build(); RouterFunction<EntityResponse<Mono<String>>> routerFunction = request -> Mono.just(handlerFunction); HandlerFilterFunction<EntityResponse<Mono<String>>, EntityResponse<Mono<Integer>>> filterFunction = (request, next) -> next.handle(request).flatMap( response -> { Mono<Integer> intMono = response.entity() .map(Integer::parseInt); return EntityResponse.fromPublisher(intMono, Integer.class).build(); }); RouterFunction<EntityResponse<Mono<Integer>>> result = routerFunction.filter(filterFunction); assertNotNull(result); MockServerRequest request = MockServerRequest.builder().build(); Mono<EntityResponse<Mono<Integer>>> responseMono = result.route(request).flatMap(hf -> hf.handle(request)); StepVerifier.create(responseMono) .consumeNextWith( serverResponse -> { StepVerifier.create(serverResponse.entity()) .expectNext(42) .expectComplete() .verify(); }) .expectComplete() .verify(); } |
### Question:
CanBeClaimed implements Feature { @Override public CanBeClaimed of(JobView jobView) { this.job = jobView; return this; } @Override CanBeClaimed of(JobView jobView); @Override Claim asJson(); }### Answer:
@Test public void should_know_if_a_failing_build_has_been_claimed() throws Exception { String ourPotentialHero = "Adam", theReason = "I broke it, sorry, fixing now"; job = a(jobView().which(new CanBeClaimed()).of( a(job().whereTheLast(build().finishedWith(FAILURE).and().wasClaimedBy(ourPotentialHero, theReason))))); assertThat(serialisedClaimOf(job).author(), is(ourPotentialHero)); assertThat(serialisedClaimOf(job).reason(), is(theReason)); }
@Test public void should_know_if_a_failing_build_has_not_been_claimed() throws Exception { job = a(jobView().which(new CanBeClaimed()).of( a(job().whereTheLast(build().finishedWith(FAILURE))))); assertThat(serialisedClaimOf(job), is(nullValue())); }
@Test public void should_complain_if_the_build_was_not_claimable() throws Exception { job = a(jobView().of( a(job().withName("my-project").whereTheLast(build().finishedWith(FAILURE))))); thrown.expectMessage("CanBeClaimed is not a feature of this project: 'my-project'"); job.which(CanBeClaimed.class); } |
### Question:
KnowsLastCompletedBuildDetails implements Feature<KnowsLastCompletedBuildDetails.LastCompletedBuild> { @Override public KnowsLastCompletedBuildDetails of(JobView jobView) { this.job = jobView; return this; } KnowsLastCompletedBuildDetails(/* config */); @Override KnowsLastCompletedBuildDetails of(JobView jobView); @Override LastCompletedBuild asJson(); }### Answer:
@Test public void should_know_the_url_of_the_last_build() { view = a(jobView().which(new KnowsLastCompletedBuildDetails()).of( a(job().whereTheLast(build().hasNumber(22)))) .with(locatedAt("job/project-name"))); assertThat(lastCompletedBuildOf(view).url(), is("job/project-name/22/")); }
@Test public void should_know_how_long_the_last_build_took_once_its_finished() throws Exception { view = a(jobView().which(new KnowsLastCompletedBuildDetails()).of( a(job().whereTheLast(build().finishedWith(SUCCESS).and().took(3))))); assertThat(lastCompletedBuildOf(view).duration(), is("3m 0s")); }
@Test public void should_know_how_long_since_the_last_build_happened() throws Exception { String tenMinutesInMilliseconds = String.format("%d", 10 * 60 * 1000); view = a(jobView().which(new KnowsLastCompletedBuildDetails()).of( a(job().whereTheLast(build().startedAt("18:05:00").and().took(5)))) .assuming(currentTime().is("18:20:00"))); assertThat(lastCompletedBuildOf(view).timeElapsedSince(), is(tenMinutesInMilliseconds)); }
@Test public void should_know_current_build_number() { view = a(jobView().which(new KnowsLastCompletedBuildDetails()).of( a(job().whereTheLast(build().hasNumber(5))))); assertThat(lastCompletedBuildOf(view).name(), is("#5")); }
@Test public void should_use_build_name_if_its_known() { view = a(jobView().which(new KnowsLastCompletedBuildDetails()).of( a(job().whereTheLast(build().hasName("1.3.4+build.15"))))); assertThat(lastCompletedBuildOf(view).name(), is("1.3.4+build.15")); } |
### Question:
HasBadgesBadgePlugin implements Feature<HasBadgesBadgePlugin.Badges> { @Override public HasBadgesBadgePlugin of(JobView jobView) { this.job = jobView; return this; } @Override HasBadgesBadgePlugin of(JobView jobView); @Override Badges asJson(); }### Answer:
@Test public void should_support_job_without_badges() throws Exception { job = a(jobView().which(new HasBadgesBadgePlugin()).of( a(job()))); assertThat(serialisedBadgesDetailsOf(job), is(nullValue())); }
@Test public void should_convert_badges_to_json() throws Exception { job = a(jobView().which(new HasBadgesBadgePlugin()).of( a(job().whereTheLast(build().hasBadgesBadgePlugin(badgePluginBadge().withText("badge1"), badgePluginBadge().withText("badge2")))))); assertThat(serialisedBadgesDetailsOf(job).value(), hasSize(2)); }
@Test public void should_ignore_badges_with_icon() throws Exception { job = a(jobView().which(new HasBadgesBadgePlugin()).of( a(job().whereTheLast(build().hasBadgesBadgePlugin(badgePluginBadge().withIcon("icon.gif", "badge1"), badgePluginBadge().withText("badge2")))))); assertThat(serialisedBadgesDetailsOf(job).value(), hasSize(1)); }
@Test public void should_report_badges_from_latest_build() throws Exception { job = a(jobView().which(new HasBadgesBadgePlugin()).of( a(job().whereTheLast(build().isStillBuilding().hasBadgesBadgePlugin(badgePluginBadge().withText("badge1"))) .andThePrevious(build().hasBadgesBadgePlugin(badgePluginBadge().withText("badge1"), badgePluginBadge().withText("badge2")))))); assertThat(serialisedBadgesDetailsOf(job).value(), hasSize(1)); } |
### Question:
KnowsCurrentBuildsDetails implements Feature<KnowsCurrentBuildsDetails.CurrentBuilds> { @Override public KnowsCurrentBuildsDetails of(JobView jobView) { this.job = jobView; return this; } KnowsCurrentBuildsDetails(/* config */); @Override KnowsCurrentBuildsDetails of(JobView jobView); @Override CurrentBuilds asJson(); }### Answer:
@Test public void should_know_current_build_number() { view = a(jobView().which(new KnowsCurrentBuildsDetails()).of( a(job().whereTheLast(build().isStillBuilding().and().hasNumber(5))))); assertThat(currentBuildsOf(view).get(0).name(), is("#5")); }
@Test public void should_use_build_name_if_its_known() { view = a(jobView().which(new KnowsCurrentBuildsDetails()).of( a(job().whereTheLast(build().isStillBuilding().and().hasName("1.3.4+build.15"))))); assertThat(currentBuildsOf(view).get(0).name(), is("1.3.4+build.15")); }
@Test public void should_know_the_url_of_the_last_build() { view = a(jobView().which(new KnowsCurrentBuildsDetails()).of( a(job().whereTheLast(build().isStillBuilding().and().hasNumber(22)))) .with(locatedAt("job/project-name"))); assertThat(currentBuildsOf(view).get(0).url(), is("job/project-name/22/")); }
@Test public void should_know_how_long_a_build_has_been_running_for() throws Exception { String startTime = "13:10:00", sixSecondsLater = "13:10:06", twoAndHalfMinutesLater = "13:12:30", anHourAndHalfLater = "14:40:00"; Date currentTime = currentTime().is(startTime); view = a(jobView().which(new KnowsCurrentBuildsDetails()).of( a(job().whereTheLast(build().startedAt(startTime).isStillBuilding()))) .assuming(currentTime)); CurrentBuild currentBuild = currentBuildsOf(view).get(0); assumeThat(currentTime).is(sixSecondsLater); assertThat(currentBuild.duration(), is("6s")); assumeThat(currentTime).is(twoAndHalfMinutesLater); assertThat(currentBuild.duration(), is("2m 30s")); assumeThat(currentTime).is(anHourAndHalfLater); assertThat(currentBuild.duration(), is("1h 30m 0s")); } |
### Question:
PipelineHelper { public static boolean isWorkflowRun(Run<?, ?> build, StaticJenkinsAPIs staticJenkinsAPIs) { if (hasWorkflowClass == null) { if (!staticJenkinsAPIs.hasPlugin(PIPELINE_PLUGIN)) { hasWorkflowClass = false; return false; } try { workflowRunClass = Class.forName(WORKFLOW_RUN_CLASS_NAME); hasWorkflowClass = true; } catch (ClassNotFoundException e) { hasWorkflowClass = false; return false; } } if (hasWorkflowClass) { return workflowRunClass.isInstance(build); } return false; } private PipelineHelper(); static boolean isWorkflowRun(Run<?, ?> build, StaticJenkinsAPIs staticJenkinsAPIs); static List<String> getPipelines(Run<?, ?> run); }### Answer:
@Test public void isWorkflowRun() { Assert.assertTrue(PipelineHelper.isWorkflowRun(workflowRun, new StaticJenkinsAPIs())); }
@Test public void isNotWorkflowRun() { Assert.assertFalse(PipelineHelper.isWorkflowRun(abstractBuild, new StaticJenkinsAPIs())); } |
### Question:
BuildMonitorInstallation { public String anonymousCorrelationId() { if (UNKNOWN.equalsIgnoreCase(anonymousCorrelationId)) { anonymousCorrelationId = sha256().hashString(jenkins.encodedPublicKey(), UTF_8).toString(); } return anonymousCorrelationId; } BuildMonitorInstallation(); BuildMonitorInstallation(StaticJenkinsAPIs jenkinsAPIs); String anonymousCorrelationId(); int size(); Audience audience(); String buildMonitorVersion(); }### Answer:
@Test public void helps_to_avoid_duplicated_stats_and_keep_jenkins_instance_anonymous() throws Exception { BuildMonitorInstallation installation = new BuildMonitorInstallation(withPublicKey(PUBLIC_KEY)); assertThat(installation.anonymousCorrelationId(), is(not(PUBLIC_KEY))); assertThat(installation.anonymousCorrelationId().length(), is(64)); }
@Test public void only_calculates_the_correlation_hash_once() throws Exception { StaticJenkinsAPIs jenkinsAPIs = withPublicKey(PUBLIC_KEY); BuildMonitorInstallation installation = new BuildMonitorInstallation(jenkinsAPIs); installation.anonymousCorrelationId(); installation.anonymousCorrelationId(); verify(jenkinsAPIs, times(1)).encodedPublicKey(); } |
### Question:
BuildMonitorDescriptor extends ViewDescriptor { public FormValidation doCheckIncludeRegex(@QueryParameter String value) { String v = Util.fixEmpty(value); if (v != null) { try { Pattern.compile(v); } catch (PatternSyntaxException pse) { return FormValidation.error(pse.getMessage()); } } return FormValidation.ok(); } BuildMonitorDescriptor(); @Override String getDisplayName(); FormValidation doCheckIncludeRegex(@QueryParameter String value); @Override boolean configure(StaplerRequest req, JSONObject json); boolean getPermissionToCollectAnonymousUsageStatistics(); @SuppressWarnings("unused") // used in global.jelly void setPermissionToCollectAnonymousUsageStatistics(boolean collect); }### Answer:
@Test public void form_validator_should_allow_valid_reg_ex_specifying_what_jobs_to_include() throws Exception { for (String regex : asFollows(null, "", ".*", "myproject-.*")) { assertThat(itShouldAllow(regex), validator.doCheckIncludeRegex(regex).kind, is(OK)); } }
@Test public void form_validator_should_advise_how_a_regex_could_be_improved() throws Exception { FormValidation result = validator.doCheckIncludeRegex(")"); assertThat(result.kind, is(ERROR)); assertThat(htmlDecoded(result.getMessage()), containsString("Unmatched closing ')'")); } |
### Question:
HasBadgesGroovyPostbuildPlugin implements Feature<HasBadgesGroovyPostbuildPlugin.Badges> { @Override public HasBadgesGroovyPostbuildPlugin of(JobView jobView) { this.job = jobView; return this; } @Override HasBadgesGroovyPostbuildPlugin of(JobView jobView); @Override Badges asJson(); }### Answer:
@Test public void should_support_job_without_badges() throws Exception { job = a(jobView().which(new HasBadgesGroovyPostbuildPlugin()).of( a(job()))); assertThat(serialisedBadgesDetailsOf(job), is(nullValue())); }
@Test public void should_convert_badges_to_json() throws Exception { job = a(jobView().which(new HasBadgesGroovyPostbuildPlugin()).of( a(job().whereTheLast(build().hasBadgesGroovyPostbuildPlugin(groovyPostbuildBadge().withText("badge1"), groovyPostbuildBadge().withText("badge2")))))); assertThat(serialisedBadgesDetailsOf(job).value(), hasSize(2)); }
@Test public void should_ignore_badges_with_icon() throws Exception { job = a(jobView().which(new HasBadgesGroovyPostbuildPlugin()).of( a(job().whereTheLast(build().hasBadgesGroovyPostbuildPlugin(groovyPostbuildBadge().withIcon("icon.gif", "badge1"), groovyPostbuildBadge().withText("badge2")))))); assertThat(serialisedBadgesDetailsOf(job).value(), hasSize(1)); }
@Test public void should_report_badges_from_latest_build() throws Exception { job = a(jobView().which(new HasBadgesGroovyPostbuildPlugin()).of( a(job().whereTheLast(build().isStillBuilding().hasBadgesGroovyPostbuildPlugin(groovyPostbuildBadge().withText("badge1"))) .andThePrevious(build().hasBadgesGroovyPostbuildPlugin(groovyPostbuildBadge().withText("badge1"), groovyPostbuildBadge().withText("badge2")))))); assertThat(serialisedBadgesDetailsOf(job).value(), hasSize(1)); } |
### Question:
CanBeDiagnosedForProblems implements Feature<CanBeDiagnosedForProblems.Problems> { @Override public CanBeDiagnosedForProblems of(JobView jobView) { this.job = jobView; return this; } CanBeDiagnosedForProblems(BuildFailureAnalyzerDisplayedField displayedField); @Override CanBeDiagnosedForProblems of(JobView jobView); @Override Problems asJson(); }### Answer:
@Test public void should_describe_known_problems() { String rogueAi = "Pod bay doors didn't open"; job = a(jobView().which(new CanBeDiagnosedForProblems(BuildFailureAnalyzerDisplayedField.Name)).of( a(job().whereTheLast(build().finishedWith(FAILURE).and().knownProblems(rogueAi))))); assertThat(diagnosedFailuresOf(job).value(), hasItem(rogueAi)); } |
### Question:
GameAnnouncement { public static GameAnnouncementFactory getFactory() { return new GameAnnouncementFactory(); } GameAnnouncement(); static GameAnnouncementFactory getFactory(); final GameType getGameType(); final CardList getDiscardedCards(); final boolean isSchneider(); final boolean isSchwarz(); final boolean isOuvert(); final boolean isHand(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); }### Answer:
@Test public void testEmptyGameType() { final GameAnnouncementFactory factory = GameAnnouncement.getFactory(); final GameAnnouncement announcement = factory.getAnnouncement(); assertNull(announcement); } |
### Question:
CardDeck extends CardList { public static EnumSet<Card> getAllCards() { EnumSet<Card> allCards = EnumSet.allOf(Card.class); return allCards; } CardDeck(); CardDeck(List<Card> foreHandCards, List<Card> middleHandCards,
List<Card> rearHandCards, List<Card> skatCards); CardDeck(String foreHandCards, String middleHandCards,
String rearHandCards, String skatCards); CardDeck(final String cards); CardDeck(final CardList cards); @Override boolean add(final Card card); static EnumSet<Card> getAllCards(); static CardDeck getPerfectDistribution(); void shuffle(); final static Map<Suit, List<Card>> SUIT_CARDS; final static Map<Rank, List<Card>> RANK_CARDS; }### Answer:
@Test public void getAllCards001() { assertThat(CardDeck.getAllCards()).hasSize(32); } |
### Question:
CardDeck extends CardList { @Override public boolean add(final Card card) { if (size() == MAX_CARDS) { throw new IllegalStateException("Card deck is already filled with " + MAX_CARDS + " cards."); } if (contains(card)) { throw new IllegalArgumentException("Card " + card + " is already contained in card deck."); } return super.add(card); } CardDeck(); CardDeck(List<Card> foreHandCards, List<Card> middleHandCards,
List<Card> rearHandCards, List<Card> skatCards); CardDeck(String foreHandCards, String middleHandCards,
String rearHandCards, String skatCards); CardDeck(final String cards); CardDeck(final CardList cards); @Override boolean add(final Card card); static EnumSet<Card> getAllCards(); static CardDeck getPerfectDistribution(); void shuffle(); final static Map<Suit, List<Card>> SUIT_CARDS; final static Map<Rank, List<Card>> RANK_CARDS; }### Answer:
@Test public void addDoubleCard() { assertThrows(IllegalArgumentException.class, () -> { final CardDeck cards = new CardDeck(); cards.remove(Card.CA); cards.add(Card.CJ); }); }
@Test public void addTooMuchCards() { assertThrows(IllegalStateException.class, () -> { final CardDeck cards = new CardDeck( "CJ SJ HJ CK CQ SK C7 C8 S7 H7 D7 DJ CA CT C9 SQ HA HK HQ S8 H8 H9 HT SA ST S9 D8 D9 DT DA DK DQ"); cards.add(Card.CJ); }); } |
### Question:
VersionChecker { public static boolean isHigherVersionAvailable(final String localVersion, final String remoteVersion) { boolean result = false; List<Integer> localVersionParts = getVersionParts(localVersion); List<Integer> remoteVersionParts = getVersionParts(remoteVersion); int previousLocalPart = 0; int previousRemotePart = 0; int index = 0; for (Integer localVersionPart : localVersionParts) { if (remoteVersionParts.size() > index) { int remoteVersionPart = remoteVersionParts.get(index); if (previousLocalPart == previousRemotePart && localVersionPart < remoteVersionPart) { result = true; } previousLocalPart = localVersionPart; previousRemotePart = remoteVersionPart; } index++; } return result; } static String getLatestVersion(); static boolean isHigherVersionAvailable(final String localVersion,
final String remoteVersion); }### Answer:
@Test public void testIsHigherVersionAvailable() { assertTrue(VersionChecker.isHigherVersionAvailable("0.10.0", "0.10.1")); assertTrue(VersionChecker.isHigherVersionAvailable("0.10.1", "1.0.0")); assertTrue(VersionChecker.isHigherVersionAvailable("0.10.1", "0.11.0")); assertFalse(VersionChecker.isHigherVersionAvailable("0.11.0", "0.10.1")); assertFalse(VersionChecker.isHigherVersionAvailable("0.10.0", "0.10.0")); assertFalse(VersionChecker.isHigherVersionAvailable("0.10.0", "0.9.0")); } |
### Question:
JSkatMaster { public void createTable() { final String tableName = view.getNewTableName(data.getLocalTablesCreated()); if (tableName == null) { log.debug("Create table was cancelled..."); return; } if (tableName.isEmpty()) { showEmptyInputNameMessage(); createTable(); return; } if (data.isFreeTableName(tableName)) { createLocalTable(tableName, view.getHumanPlayerForGUI()); } else { JSkatEventBus.INSTANCE.post(new DuplicateTableNameInputEvent(tableName)); createTable(); } } private JSkatMaster(); void checkJSkatVersion(final String latestLocalVersion, final String latestRemoteVersion); void createTable(); @Deprecated JSkatView getView(); @Subscribe void removeTableDataOn(final TableRemovedEvent event); void invitePlayer(); void startSeries(final List<String> allPlayer, final List<String> playerNames, final int numberOfRounds,
final boolean unlimited,
final boolean onlyPlayRamsch, final int sleeps); JSkatPlayer createPlayer(final String player); synchronized boolean placePlayer(final String tableName, final JSkatPlayer player); void setView(final JSkatView newView); void exitJSkat(); void showEmptyInputNameMessage(); void triggerHuman(final JSkatActionEvent event); void takeCardFromSkat(final JSkatActionEvent e); void putCardIntoSkat(final JSkatActionEvent event); IssController getIssController(); void setActiveTable(final String tableName); void setActiveTable(final JSkatViewType type, final String tableName); @Subscribe void setLoginNameOn(final IssConnectedEvent event); void leaveTable(); void updateISSPlayer(final String playerName, final String language, final long gamesPlayed,
final double strength); void removeISSPlayer(final String playerName); void openIssHomepage(); void openIssRegisterPage(); final static JSkatMaster INSTANCE; }### Answer:
@Test public void createTable() { final UnitTestView view = new UnitTestView(); JSkatMaster.INSTANCE.setView(view); JSkatMaster.INSTANCE.createTable(); assertThat(view.tables.size()).isEqualTo(1); assertTrue(view.tables.contains("UnitTestTable 1")); JSkatMaster.INSTANCE.createTable(); assertThat(view.tables.size()).isEqualTo(2); assertTrue(view.tables.contains("UnitTestTable 1")); assertTrue(view.tables.contains("UnitTestTable 2")); } |
### Question:
NullRule extends AbstractSkatRule { @Override public int calcGameResult(final SkatGameData gameData) { int result = getGameValueForWonGame(gameData); if (gameData.isGameLost()) { result = result * -2; } return result; } @Override int getGameValueForWonGame(final SkatGameData gameData); @Override int calcGameResult(final SkatGameData gameData); @Override boolean isCardBeatsCard(
@SuppressWarnings("unused") final GameType gameType,
final Card cardToBeat, final Card card); @Override boolean isCardAllowed(final GameType gameType,
final Card initialCard, final CardList hand, final Card card); @Override boolean isGameWon(final SkatGameData gameData); @Override boolean hasSuit(final GameType gameType, final CardList hand,
final Suit suit); @Override int getMultiplier(
@SuppressWarnings("unused") final SkatGameData gameData); @Override boolean isPlayWithJacks(
@SuppressWarnings("unused") final SkatGameData gameData); }### Answer:
@Test public void calcGameResultGameLostHand() { factory.setHand(true); data.setAnnouncement(factory.getAnnouncement()); playWinningTricks(); playLoosingTrick(); data.calcResult(); assertThat(nullRules.calcGameResult(data)).isEqualTo(-70); }
@Test public void calcGameResultGameLostOuvert() { factory.setHand(false); factory.setOuvert(Boolean.TRUE); data.setAnnouncement(factory.getAnnouncement()); playWinningTricks(); playLoosingTrick(); data.calcResult(); assertThat(nullRules.calcGameResult(data)).isEqualTo(-92); }
@Test public void calcGameResultGameLostHandOuvert() { factory.setHand(true); factory.setOuvert(true); data.setAnnouncement(factory.getAnnouncement()); playWinningTricks(); playLoosingTrick(); data.calcResult(); assertThat(nullRules.calcGameResult(data)).isEqualTo(-118); } |
### Question:
MessageParser { static TablePanelStatus getTableStatus(final String loginName, final List<String> params) { final TablePanelStatus status = new TablePanelStatus(); status.setLoginName(loginName); status.setMaxPlayers(Integer.parseInt(params.get(0))); for (int i = 0; i < status.getMaxPlayers(); i++) { if (!".".equals(params.get(i * 10 + 5))) { final PlayerStatus playerStatus = parsePlayerStatus(params .subList(i * 10 + 5, i * 10 + 16)); if (".".equals(params.get(i + 1))) { playerStatus.setPlayerLeft(true); } status.addPlayer(playerStatus.getName(), playerStatus); } } return status; } }### Answer:
@Test public void testParseTableUpdatePlayerLeft() { final String tableUpdate = "table .4 foo state 3 foo . . . foo . 0 0 0 0 0 0 1 0 xskat $ 2 1 83 157 0 0 1 0 xskat:2 $ 0 0 0 0 0 0 1 0 . . 0 0 0 0 0 0 0 0 false 0"; final StringTokenizer token = new StringTokenizer(tableUpdate); token.nextToken(); token.nextToken(); final String creator = token.nextToken(); token.nextToken(); final List<String> detailParams = new ArrayList<>(); while (token.hasMoreTokens()) { detailParams.add(token.nextToken()); } final TablePanelStatus status = MessageParser.getTableStatus(creator, detailParams); assertThat(status.getMaxPlayers()).isEqualTo(3); assertThat(status.getPlayerInformations()).hasSize(3); final PlayerStatus playerStatus = status.getPlayerInformation("xskat"); assertNotNull(playerStatus); assertThat(playerStatus.getGamesPlayed()).isEqualTo(2); assertThat(playerStatus.getGamesWon()).isEqualTo(1); assertThat(playerStatus.getLastGameResult()).isEqualTo(83); assertThat(playerStatus.getTotalPoints()).isEqualTo(157); assertTrue(playerStatus.isPlayerLeft()); assertFalse(playerStatus.isReadyToPlay()); assertTrue(playerStatus.isTalkEnabled()); } |
### Question:
JSkatPlayerResolver { public static Set<String> getAllAIPlayerImplementations() { final Set<String> result = getAllImplementations(); result.removeAll(EXCLUDED_PLAYER_CLASSES); result.removeAll(UNIT_TEST_PLAYER_CLASSES); LOG.info("Found {} implementations of AbstractJSkatPlayer.", result.size()); return result; } static Set<String> getAllAIPlayerImplementations(); static final String HUMAN_PLAYER_CLASS; static final Set<String> EXCLUDED_PLAYER_CLASSES; static final Set<String> UNIT_TEST_PLAYER_CLASSES; }### Answer:
@Test public void testGetAllAIPlayerImplementations() { final Set<String> implementations = JSkatPlayerResolver.getAllAIPlayerImplementations(); assertThat(implementations).hasSize(2); } |
### Question:
BidEvaluator { int getMaxBid() { return maxBid; } BidEvaluator(final CardList cards); }### Answer:
@Test public void testGetMaxBid() { log.debug("++++++++++++++++++++++++++++++++++++++++++++++++++++++++"); final CardList cards = new CardList(Arrays.asList(Card.CJ, Card.DJ, Card.CA, Card.CK, Card.CQ, Card.C8, Card.SQ, Card.HT, Card.H8, Card.D9)); BidEvaluator eval = new BidEvaluator(cards); assertThat(eval.getMaxBid()).isEqualTo(24); cards.remove(Card.DJ); cards.add(Card.SJ); cards.sort(null); eval = new BidEvaluator(cards); assertThat(eval.getMaxBid()).isEqualTo(36); log.debug("++++++++++++++++++++++++++++++++++++++++++++++++++++++++"); } |
### Question:
AlgorithmOpponentGrand extends AbstractAlgorithmAI { @Override protected Card startGame() { log.debug("OpponentGrand starts Game: " + knowledge.getPlayerPosition()); return playStartGameCard(knowledge.getOwnCards(), knowledge.getTrickCards(), oPlayedCards, oNotOpponentCards, oSituation, knowledge.getDeclarer()); } AlgorithmOpponentGrand(final AlgorithmAI p, final GameType pGameType); @Override CardList discardSkat(final BidEvaluator bidEvaluator); static Card playStartGameCard(final CardList pCards, final CardList pTrickCards,
final CardList pPlayedCards, final CardList pNotOpponentCards,
final Situation pSituation, final Player pDeclarer); static Card playForehandCard(final CardList pCards, final CardList pTrickCards,
final CardList pPlayedCards, final CardList pNotOpponentCards,
final Situation pSituation, final Player pDeclarer); static Card playMiddlehandCard(final CardList pCards,
final CardList pTrickCards, final CardList pPlayedCards,
final CardList pNotOpponentCards, final Situation pSituation, final Player pDeclarer); static Card playRearhandCard(final CardList pCards, final CardList pTrickCards,
final CardList pPlayedCards, final CardList pNotOpponentCards,
final Situation pSituation, final Player pPlayerPosition, final Player pDeclarer); static Card getHighValueCard(final CardList pCards, final Situation pSituation,
final Card pInitialCard); static Card getLowValueCard(final CardList pCards, final Situation pSituation,
final Card pInitialCard, final CardList pPlayedCards, final CardList pTrickCards); }### Answer:
@Test public void testOpponentPlayerFollowsJackInGrandGame() { final UnitTestPlayer deterministicPlayer = new UnitTestPlayer(); deterministicPlayer.setCardsToPlay(Lists.newArrayList(Card.SJ)); final AlgorithmAI faultyPlayer = new AlgorithmAI(); final JSkatPlayer helperPlayer = new UnitTestPlayer(); deterministicPlayer.newGame(Player.FOREHAND); faultyPlayer.newGame(Player.MIDDLEHAND); helperPlayer.newGame(Player.REARHAND); final SkatGame skatGame = new SkatGame(TABLE_NAME, GameVariant.STANDARD, deterministicPlayer, faultyPlayer, helperPlayer); skatGame.setView(new UnitTestView()); skatGame.setCardDeck(new CardDeck("SJ DJ CA CT CK CQ C9 C8 C7 SA", "CJ ST SK SQ S9 S8 S7 HA HT HK", "HJ HQ H9 H8 H7 DA DT DK DQ D9", "D8 D7")); skatGame.dealCards(); skatGame.setDeclarer(Player.FOREHAND); final GameAnnouncementFactory announcementFactory = GameAnnouncement.getFactory(); announcementFactory.setGameType(GameType.GRAND); final GameAnnouncement announcement = announcementFactory.getAnnouncement(); skatGame.setGameAnnouncement(announcement); deterministicPlayer.startGame(Player.FOREHAND, announcement); faultyPlayer.startGame(Player.FOREHAND, announcement); helperPlayer.startGame(Player.FOREHAND, announcement); skatGame.setGameState(GameState.TRICK_PLAYING); final SkatGameResult gameResult = skatGame.run(); assertTrue(gameResult.isWon()); assertAlgorithmAIPlayerFollowsJack(skatGame); } |
### Question:
RamschRule extends SuitGrandRamschRule { @Override public int getMultiplier(final SkatGameData gameData) { int multiplier = 1; if (gameData.isJungfrau()) { log.debug("One player is jungfrau"); multiplier = 2; } log.debug(gameData.getGeschoben() + " player did schieben"); multiplier = (int) (multiplier * Math.pow(2, gameData.getGeschoben())); return multiplier; } @Override int getGameValueForWonGame(final SkatGameData gameData); @Override int calcGameResult(final SkatGameData gameData); @Override boolean isGameWon(final SkatGameData gameData); static final boolean isDurchmarsch(final Player player,
final SkatGameData gameData); static final boolean isJungfrau(final Player player,
final SkatGameData gameData); @Override int getMultiplier(final SkatGameData gameData); @Override boolean isPlayWithJacks(final SkatGameData gameData); }### Answer:
@Test public void testGetMultiplierGeschoben() { assertThat(ramschRules.getMultiplier(data)).isEqualTo(1); data.addGeschoben(); assertThat(ramschRules.getMultiplier(data)).isEqualTo(2); data.addGeschoben(); assertThat(ramschRules.getMultiplier(data)).isEqualTo(4); data.addGeschoben(); assertThat(ramschRules.getMultiplier(data)).isEqualTo(8); } |
### Question:
CardList implements Iterable<Card> { public int getFirstIndexOfSuit(final Suit suit, final boolean includeJacks) { int result = -1; int index = 0; for (Card card : cards) { if (result == -1 && card.getSuit() == suit) { if (card.getRank() != Rank.JACK || card.getRank() == Rank.JACK && includeJacks) { result = index; } } index++; } return result; } CardList(); CardList(final List<Card> newCards); CardList(final CardList newCards); CardList(Card... cards); CardList getImmutableCopy(); boolean remove(final Card card); boolean add(final Card card); boolean addAll(final CardList newCards); boolean addAll(final Collection<Card> newCards); int size(); boolean isEmpty(); @Override Iterator<Card> iterator(); boolean contains(final Card card); Card remove(final int index); boolean removeAll(final Collection<Card> cardsToRemove); boolean removeAll(final CardList cardsToRemove); void clear(); int indexOf(final Card card); boolean hasSuit(final GameType gameType, final Suit suit); boolean hasTrump(final GameType gameType); boolean hasJack(final Suit suit); void set(final int index, final Card card); Card get(final int index); int getIndexOf(final Card card); Suit getMostFrequentSuit(); Suit getMostFrequentSuit(final Suit exclude); int getSuitCount(final Suit suit, final boolean countJack); int getTrumpCount(final Suit trumpSuit); void sort(final GameType gameType); @Override String toString(); int getFirstIndexOfSuit(final Suit suit,
final boolean includeJacks); int getFirstIndexOfSuit(final Suit suit); int getLastIndexOfSuit(final Suit suit); int getLastIndexOfSuit(final Suit suit, final boolean includeJacks); int getTotalValue(); int[] toBinary(); String dumpFlag(); @Override int hashCode(); @Override boolean equals(Object obj); final static CardList getPerfectGrandSuitHand(); final static CardList getRandomCards(int cardCount); }### Answer:
@Test public void testGetFirstIndexOfSuit() { final CardList cards = new CardList(); cards.add(Card.CJ); cards.add(Card.CA); assertThat(cards.getFirstIndexOfSuit(Suit.CLUBS)).isEqualTo(0); assertThat(cards.getFirstIndexOfSuit(Suit.CLUBS, true)).isEqualTo(0); assertThat(cards.getFirstIndexOfSuit(Suit.CLUBS, false)).isEqualTo(1); assertThat(cards.getFirstIndexOfSuit(Suit.HEARTS)).isEqualTo(-1); } |
### Question:
CardList implements Iterable<Card> { public int getLastIndexOfSuit(final Suit suit) { return getLastIndexOfSuit(suit, true); } CardList(); CardList(final List<Card> newCards); CardList(final CardList newCards); CardList(Card... cards); CardList getImmutableCopy(); boolean remove(final Card card); boolean add(final Card card); boolean addAll(final CardList newCards); boolean addAll(final Collection<Card> newCards); int size(); boolean isEmpty(); @Override Iterator<Card> iterator(); boolean contains(final Card card); Card remove(final int index); boolean removeAll(final Collection<Card> cardsToRemove); boolean removeAll(final CardList cardsToRemove); void clear(); int indexOf(final Card card); boolean hasSuit(final GameType gameType, final Suit suit); boolean hasTrump(final GameType gameType); boolean hasJack(final Suit suit); void set(final int index, final Card card); Card get(final int index); int getIndexOf(final Card card); Suit getMostFrequentSuit(); Suit getMostFrequentSuit(final Suit exclude); int getSuitCount(final Suit suit, final boolean countJack); int getTrumpCount(final Suit trumpSuit); void sort(final GameType gameType); @Override String toString(); int getFirstIndexOfSuit(final Suit suit,
final boolean includeJacks); int getFirstIndexOfSuit(final Suit suit); int getLastIndexOfSuit(final Suit suit); int getLastIndexOfSuit(final Suit suit, final boolean includeJacks); int getTotalValue(); int[] toBinary(); String dumpFlag(); @Override int hashCode(); @Override boolean equals(Object obj); final static CardList getPerfectGrandSuitHand(); final static CardList getRandomCards(int cardCount); }### Answer:
@Test public void testGetLastIndexOfSuit() { final CardList cards = new CardList(); cards.add(Card.CA); cards.add(Card.CJ); assertThat(cards.getLastIndexOfSuit(Suit.CLUBS)).isEqualTo(1); assertThat(cards.getLastIndexOfSuit(Suit.CLUBS, true)).isEqualTo(1); assertThat(cards.getLastIndexOfSuit(Suit.CLUBS, false)).isEqualTo(0); assertThat(cards.getLastIndexOfSuit(Suit.HEARTS)).isEqualTo(-1); } |
### Question:
CardList implements Iterable<Card> { public final static CardList getPerfectGrandSuitHand() { return new CardList(Card.CJ, Card.SJ, Card.HJ, Card.DJ, Card.CA, Card.SA, Card.HA, Card.DA, Card.CT, Card.ST); } CardList(); CardList(final List<Card> newCards); CardList(final CardList newCards); CardList(Card... cards); CardList getImmutableCopy(); boolean remove(final Card card); boolean add(final Card card); boolean addAll(final CardList newCards); boolean addAll(final Collection<Card> newCards); int size(); boolean isEmpty(); @Override Iterator<Card> iterator(); boolean contains(final Card card); Card remove(final int index); boolean removeAll(final Collection<Card> cardsToRemove); boolean removeAll(final CardList cardsToRemove); void clear(); int indexOf(final Card card); boolean hasSuit(final GameType gameType, final Suit suit); boolean hasTrump(final GameType gameType); boolean hasJack(final Suit suit); void set(final int index, final Card card); Card get(final int index); int getIndexOf(final Card card); Suit getMostFrequentSuit(); Suit getMostFrequentSuit(final Suit exclude); int getSuitCount(final Suit suit, final boolean countJack); int getTrumpCount(final Suit trumpSuit); void sort(final GameType gameType); @Override String toString(); int getFirstIndexOfSuit(final Suit suit,
final boolean includeJacks); int getFirstIndexOfSuit(final Suit suit); int getLastIndexOfSuit(final Suit suit); int getLastIndexOfSuit(final Suit suit, final boolean includeJacks); int getTotalValue(); int[] toBinary(); String dumpFlag(); @Override int hashCode(); @Override boolean equals(Object obj); final static CardList getPerfectGrandSuitHand(); final static CardList getRandomCards(int cardCount); }### Answer:
@Test public void testPerfectGrandSuitHand() { final CardList cards = CardList.getPerfectGrandSuitHand(); assertThat(cards).containsExactlyInAnyOrder( Card.CJ, Card.SJ, Card.HJ, Card.DJ, Card.CA, Card.SA, Card.HA, Card.DA, Card.CT, Card.ST); } |
### Question:
CardList implements Iterable<Card> { public final static CardList getRandomCards(int cardCount) { CardDeck cardDeck = new CardDeck(); CardList result = new CardList(); for (int i = 0; i < cardCount; i++) { result.add(cardDeck.remove(RANDOM.nextInt(cardDeck.size()))); } return result; } CardList(); CardList(final List<Card> newCards); CardList(final CardList newCards); CardList(Card... cards); CardList getImmutableCopy(); boolean remove(final Card card); boolean add(final Card card); boolean addAll(final CardList newCards); boolean addAll(final Collection<Card> newCards); int size(); boolean isEmpty(); @Override Iterator<Card> iterator(); boolean contains(final Card card); Card remove(final int index); boolean removeAll(final Collection<Card> cardsToRemove); boolean removeAll(final CardList cardsToRemove); void clear(); int indexOf(final Card card); boolean hasSuit(final GameType gameType, final Suit suit); boolean hasTrump(final GameType gameType); boolean hasJack(final Suit suit); void set(final int index, final Card card); Card get(final int index); int getIndexOf(final Card card); Suit getMostFrequentSuit(); Suit getMostFrequentSuit(final Suit exclude); int getSuitCount(final Suit suit, final boolean countJack); int getTrumpCount(final Suit trumpSuit); void sort(final GameType gameType); @Override String toString(); int getFirstIndexOfSuit(final Suit suit,
final boolean includeJacks); int getFirstIndexOfSuit(final Suit suit); int getLastIndexOfSuit(final Suit suit); int getLastIndexOfSuit(final Suit suit, final boolean includeJacks); int getTotalValue(); int[] toBinary(); String dumpFlag(); @Override int hashCode(); @Override boolean equals(Object obj); final static CardList getPerfectGrandSuitHand(); final static CardList getRandomCards(int cardCount); }### Answer:
@Test public void testRandomCards() { final CardList cards = CardList.getRandomCards(10); assertThat(cards).hasSize(10); } |
### Question:
SkatConstants { public static final int getTournamentGameValue(boolean declarer, int gameValue, int numberOfPlayers) { int result = 0; if (declarer) { if (gameValue > 0) { result = gameValue + 50; } else { result = gameValue - 50; } } else { if (gameValue < 0) { if (numberOfPlayers == 3) { result = 40; } else if (numberOfPlayers == 4) { result = 30; } } } return result; } static final int getNextBidValue(int currBidValue); static final int getGameBaseValue(GameType gameType, boolean hand,
boolean ouvert); static final int getTournamentGameValue(boolean declarer,
int gameValue, int numberOfPlayers); static final List<Integer> bidOrder; static final Integer MIN_WINNING_POINTS; static final Integer MIN_SCHNEIDER_WINNING_POINTS; static final Integer MIN_SCHWARZ_WINNING_POINTS; }### Answer:
@Test public void getTournamentGameValue001() { assertThat(SkatConstants.getTournamentGameValue(true, 18, 3)).isEqualTo(68); assertThat(SkatConstants.getTournamentGameValue(true, 18, 4)).isEqualTo(68); assertThat(SkatConstants.getTournamentGameValue(true, -36, 3)).isEqualTo(-86); assertThat(SkatConstants.getTournamentGameValue(true, -36, 4)).isEqualTo(-86); assertThat(SkatConstants.getTournamentGameValue(true, 20, 3)).isEqualTo(70); assertThat(SkatConstants.getTournamentGameValue(true, 20, 4)).isEqualTo(70); assertThat(SkatConstants.getTournamentGameValue(true, -40, 3)).isEqualTo(-90); assertThat(SkatConstants.getTournamentGameValue(true, -40, 4)).isEqualTo(-90); assertThat(SkatConstants.getTournamentGameValue(false, 18, 3)).isEqualTo(0); assertThat(SkatConstants.getTournamentGameValue(false, 18, 4)).isEqualTo(0); assertThat(SkatConstants.getTournamentGameValue(false, -36, 3)).isEqualTo(40); assertThat(SkatConstants.getTournamentGameValue(false, -36, 4)).isEqualTo(30); assertThat(SkatConstants.getTournamentGameValue(false, 20, 3)).isEqualTo(0); assertThat(SkatConstants.getTournamentGameValue(false, 20, 4)).isEqualTo(0); assertThat(SkatConstants.getTournamentGameValue(false, -40, 3)).isEqualTo(40); assertThat(SkatConstants.getTournamentGameValue(false, -40, 4)).isEqualTo(30); } |
### Question:
ProductServiceImpl implements ProductService { @Override public ProductInfo findOne(String productId) { return repository.findOne(productId); } @Override ProductInfo findOne(String productId); @Override List<ProductInfo> findUpAll(); @Override Page<ProductInfo> findAll(Pageable pageable); @Override ProductInfo save(ProductInfo productInfo); @Override @Transactional void increaseStock(List<CartDTO> cartDTOList); @Override @Transactional void decreaseStock(List<CartDTO> cartDTOList); @Override ProductInfo onSale(String productId); @Override ProductInfo offSale(String productId); }### Answer:
@Test public void findOne() throws Exception { ProductInfo productInfo = productService.findOne("123456"); Assert.assertEquals("123456", productInfo.getProductId()); } |
### Question:
CategoryServiceImpl implements CategoryService { @Override public List<ProductCategory> findByCategoryTypeIn(List<Integer> categoryTypeList) { return repository.findByCategoryTypeIn(categoryTypeList); } @Override ProductCategory findOne(Integer categoryId); @Override List<ProductCategory> findAll(); @Override List<ProductCategory> findByCategoryTypeIn(List<Integer> categoryTypeList); @Override ProductCategory save(ProductCategory productCategory); }### Answer:
@Test public void findByCategoryTypeIn() throws Exception { List<ProductCategory> productCategoryList = categoryService.findByCategoryTypeIn(Arrays.asList(1,2,3,4)); Assert.assertNotEquals(0, productCategoryList.size()); } |
### Question:
CategoryServiceImpl implements CategoryService { @Override public ProductCategory save(ProductCategory productCategory) { return repository.save(productCategory); } @Override ProductCategory findOne(Integer categoryId); @Override List<ProductCategory> findAll(); @Override List<ProductCategory> findByCategoryTypeIn(List<Integer> categoryTypeList); @Override ProductCategory save(ProductCategory productCategory); }### Answer:
@Test public void save() throws Exception { ProductCategory productCategory = new ProductCategory("男生专享", 10); ProductCategory result = categoryService.save(productCategory); Assert.assertNotNull(result); } |
### Question:
OrderServiceImpl implements OrderService { @Override @Transactional public OrderDTO create(OrderDTO orderDTO) { String orderId = KeyUtil.genUniqueKey(); BigDecimal orderAmount = new BigDecimal(BigInteger.ZERO); for (OrderDetail orderDetail: orderDTO.getOrderDetailList()) { ProductInfo productInfo = productService.findOne(orderDetail.getProductId()); if (productInfo == null) { throw new SellException(ResultEnum.PRODUCT_NOT_EXIST); } orderAmount = productInfo.getProductPrice() .multiply(new BigDecimal(orderDetail.getProductQuantity())) .add(orderAmount); orderDetail.setDetailId(KeyUtil.genUniqueKey()); orderDetail.setOrderId(orderId); BeanUtils.copyProperties(productInfo, orderDetail); orderDetailRepository.save(orderDetail); } OrderMaster orderMaster = new OrderMaster(); orderDTO.setOrderId(orderId); BeanUtils.copyProperties(orderDTO, orderMaster); orderMaster.setOrderAmount(orderAmount); orderMaster.setOrderStatus(OrderStatusEnum.NEW.getCode()); orderMaster.setPayStatus(PayStatusEnum.WAIT.getCode()); orderMasterRepository.save(orderMaster); List<CartDTO> cartDTOList = orderDTO.getOrderDetailList().stream().map(e -> new CartDTO(e.getProductId(), e.getProductQuantity()) ).collect(Collectors.toList()); productService.decreaseStock(cartDTOList); webSocket.sendMessage(orderDTO.getOrderId()); return orderDTO; } @Override @Transactional OrderDTO create(OrderDTO orderDTO); @Override OrderDTO findOne(String orderId); @Override Page<OrderDTO> findList(String buyerOpenid, Pageable pageable); @Override @Transactional OrderDTO cancel(OrderDTO orderDTO); @Override @Transactional OrderDTO finish(OrderDTO orderDTO); @Override @Transactional OrderDTO paid(OrderDTO orderDTO); @Override Page<OrderDTO> findList(Pageable pageable); }### Answer:
@Test public void create() throws Exception { OrderDTO orderDTO = new OrderDTO(); orderDTO.setBuyerName("廖师兄"); orderDTO.setBuyerAddress("幕课网"); orderDTO.setBuyerPhone("123456789012"); orderDTO.setBuyerOpenid(BUYER_OPENID); List<OrderDetail> orderDetailList = new ArrayList<>(); OrderDetail o1 = new OrderDetail(); o1.setProductId("1234568"); o1.setProductQuantity(1); OrderDetail o2 = new OrderDetail(); o2.setProductId("123457"); o2.setProductQuantity(2); orderDetailList.add(o1); orderDetailList.add(o2); orderDTO.setOrderDetailList(orderDetailList); OrderDTO result = orderService.create(orderDTO); log.info("【创建订单】result={}", result); Assert.assertNotNull(result); } |
### Question:
OrderServiceImpl implements OrderService { @Override public OrderDTO findOne(String orderId) { OrderMaster orderMaster = orderMasterRepository.findOne(orderId); if (orderMaster == null) { throw new SellException(ResultEnum.ORDER_NOT_EXIST); } List<OrderDetail> orderDetailList = orderDetailRepository.findByOrderId(orderId); if (CollectionUtils.isEmpty(orderDetailList)) { throw new SellException(ResultEnum.ORDERDETAIL_NOT_EXIST); } OrderDTO orderDTO = new OrderDTO(); BeanUtils.copyProperties(orderMaster, orderDTO); orderDTO.setOrderDetailList(orderDetailList); return orderDTO; } @Override @Transactional OrderDTO create(OrderDTO orderDTO); @Override OrderDTO findOne(String orderId); @Override Page<OrderDTO> findList(String buyerOpenid, Pageable pageable); @Override @Transactional OrderDTO cancel(OrderDTO orderDTO); @Override @Transactional OrderDTO finish(OrderDTO orderDTO); @Override @Transactional OrderDTO paid(OrderDTO orderDTO); @Override Page<OrderDTO> findList(Pageable pageable); }### Answer:
@Test public void findOne() throws Exception { OrderDTO result = orderService.findOne(ORDER_ID); log.info("【查询单个订单】result={}", result); Assert.assertEquals(ORDER_ID, result.getOrderId()); } |
### Question:
OrderServiceImpl implements OrderService { @Override public Page<OrderDTO> findList(String buyerOpenid, Pageable pageable) { Page<OrderMaster> orderMasterPage = orderMasterRepository.findByBuyerOpenid(buyerOpenid, pageable); List<OrderDTO> orderDTOList = OrderMaster2OrderDTOConverter.convert(orderMasterPage.getContent()); return new PageImpl<OrderDTO>(orderDTOList, pageable, orderMasterPage.getTotalElements()); } @Override @Transactional OrderDTO create(OrderDTO orderDTO); @Override OrderDTO findOne(String orderId); @Override Page<OrderDTO> findList(String buyerOpenid, Pageable pageable); @Override @Transactional OrderDTO cancel(OrderDTO orderDTO); @Override @Transactional OrderDTO finish(OrderDTO orderDTO); @Override @Transactional OrderDTO paid(OrderDTO orderDTO); @Override Page<OrderDTO> findList(Pageable pageable); }### Answer:
@Test public void findList() throws Exception { PageRequest request = new PageRequest(0,2); Page<OrderDTO> orderDTOPage = orderService.findList(BUYER_OPENID, request); Assert.assertNotEquals(0, orderDTOPage.getTotalElements()); }
@Test public void list() { PageRequest request = new PageRequest(0,2); Page<OrderDTO> orderDTOPage = orderService.findList(request); Assert.assertTrue("查询所有的订单列表", orderDTOPage.getTotalElements() > 0); } |
### Question:
OrderServiceImpl implements OrderService { @Override @Transactional public OrderDTO cancel(OrderDTO orderDTO) { OrderMaster orderMaster = new OrderMaster(); if (!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())) { log.error("【取消订单】订单状态不正确, orderId={}, orderStatus={}", orderDTO.getOrderId(), orderDTO.getOrderStatus()); throw new SellException(ResultEnum.ORDER_STATUS_ERROR); } orderDTO.setOrderStatus(OrderStatusEnum.CANCEL.getCode()); BeanUtils.copyProperties(orderDTO, orderMaster); OrderMaster updateResult = orderMasterRepository.save(orderMaster); if (updateResult == null) { log.error("【取消订单】更新失败, orderMaster={}", orderMaster); throw new SellException(ResultEnum.ORDER_UPDATE_FAIL); } if (CollectionUtils.isEmpty(orderDTO.getOrderDetailList())) { log.error("【取消订单】订单中无商品详情, orderDTO={}", orderDTO); throw new SellException(ResultEnum.ORDER_DETAIL_EMPTY); } List<CartDTO> cartDTOList = orderDTO.getOrderDetailList().stream() .map(e -> new CartDTO(e.getProductId(), e.getProductQuantity())) .collect(Collectors.toList()); productService.increaseStock(cartDTOList); if (orderDTO.getPayStatus().equals(PayStatusEnum.SUCCESS.getCode())) { payService.refund(orderDTO); } return orderDTO; } @Override @Transactional OrderDTO create(OrderDTO orderDTO); @Override OrderDTO findOne(String orderId); @Override Page<OrderDTO> findList(String buyerOpenid, Pageable pageable); @Override @Transactional OrderDTO cancel(OrderDTO orderDTO); @Override @Transactional OrderDTO finish(OrderDTO orderDTO); @Override @Transactional OrderDTO paid(OrderDTO orderDTO); @Override Page<OrderDTO> findList(Pageable pageable); }### Answer:
@Test public void cancel() throws Exception { OrderDTO orderDTO = orderService.findOne(ORDER_ID); OrderDTO result = orderService.cancel(orderDTO); Assert.assertEquals(OrderStatusEnum.CANCEL.getCode(), result.getOrderStatus()); } |
### Question:
OrderServiceImpl implements OrderService { @Override @Transactional public OrderDTO finish(OrderDTO orderDTO) { if (!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())) { log.error("【完结订单】订单状态不正确, orderId={}, orderStatus={}", orderDTO.getOrderId(), orderDTO.getOrderStatus()); throw new SellException(ResultEnum.ORDER_STATUS_ERROR); } orderDTO.setOrderStatus(OrderStatusEnum.FINISHED.getCode()); OrderMaster orderMaster = new OrderMaster(); BeanUtils.copyProperties(orderDTO, orderMaster); OrderMaster updateResult = orderMasterRepository.save(orderMaster); if (updateResult == null) { log.error("【完结订单】更新失败, orderMaster={}", orderMaster); throw new SellException(ResultEnum.ORDER_UPDATE_FAIL); } pushMessageService.orderStatus(orderDTO); return orderDTO; } @Override @Transactional OrderDTO create(OrderDTO orderDTO); @Override OrderDTO findOne(String orderId); @Override Page<OrderDTO> findList(String buyerOpenid, Pageable pageable); @Override @Transactional OrderDTO cancel(OrderDTO orderDTO); @Override @Transactional OrderDTO finish(OrderDTO orderDTO); @Override @Transactional OrderDTO paid(OrderDTO orderDTO); @Override Page<OrderDTO> findList(Pageable pageable); }### Answer:
@Test public void finish() throws Exception { OrderDTO orderDTO = orderService.findOne(ORDER_ID); OrderDTO result = orderService.finish(orderDTO); Assert.assertEquals(OrderStatusEnum.FINISHED.getCode(), result.getOrderStatus()); } |
### Question:
OrderServiceImpl implements OrderService { @Override @Transactional public OrderDTO paid(OrderDTO orderDTO) { if (!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())) { log.error("【订单支付完成】订单状态不正确, orderId={}, orderStatus={}", orderDTO.getOrderId(), orderDTO.getOrderStatus()); throw new SellException(ResultEnum.ORDER_STATUS_ERROR); } if (!orderDTO.getPayStatus().equals(PayStatusEnum.WAIT.getCode())) { log.error("【订单支付完成】订单支付状态不正确, orderDTO={}", orderDTO); throw new SellException(ResultEnum.ORDER_PAY_STATUS_ERROR); } orderDTO.setPayStatus(PayStatusEnum.SUCCESS.getCode()); OrderMaster orderMaster = new OrderMaster(); BeanUtils.copyProperties(orderDTO, orderMaster); OrderMaster updateResult = orderMasterRepository.save(orderMaster); if (updateResult == null) { log.error("【订单支付完成】更新失败, orderMaster={}", orderMaster); throw new SellException(ResultEnum.ORDER_UPDATE_FAIL); } return orderDTO; } @Override @Transactional OrderDTO create(OrderDTO orderDTO); @Override OrderDTO findOne(String orderId); @Override Page<OrderDTO> findList(String buyerOpenid, Pageable pageable); @Override @Transactional OrderDTO cancel(OrderDTO orderDTO); @Override @Transactional OrderDTO finish(OrderDTO orderDTO); @Override @Transactional OrderDTO paid(OrderDTO orderDTO); @Override Page<OrderDTO> findList(Pageable pageable); }### Answer:
@Test public void paid() throws Exception { OrderDTO orderDTO = orderService.findOne(ORDER_ID); OrderDTO result = orderService.paid(orderDTO); Assert.assertEquals(PayStatusEnum.SUCCESS.getCode(), result.getPayStatus()); } |
### Question:
PayServiceImpl implements PayService { @Override public PayResponse create(OrderDTO orderDTO) { PayRequest payRequest = new PayRequest(); payRequest.setOpenid(orderDTO.getBuyerOpenid()); payRequest.setOrderAmount(orderDTO.getOrderAmount().doubleValue()); payRequest.setOrderId(orderDTO.getOrderId()); payRequest.setOrderName(ORDER_NAME); payRequest.setPayTypeEnum(BestPayTypeEnum.WXPAY_H5); log.info("【微信支付】发起支付, request={}", JsonUtil.toJson(payRequest)); PayResponse payResponse = bestPayService.pay(payRequest); log.info("【微信支付】发起支付, response={}", JsonUtil.toJson(payResponse)); return payResponse; } @Override PayResponse create(OrderDTO orderDTO); @Override PayResponse notify(String notifyData); @Override RefundResponse refund(OrderDTO orderDTO); }### Answer:
@Test public void create() throws Exception { OrderDTO orderDTO = orderService.findOne("1499097366838352541"); payService.create(orderDTO); } |
### Question:
ProductServiceImpl implements ProductService { @Override public List<ProductInfo> findUpAll() { return repository.findByProductStatus(ProductStatusEnum.UP.getCode()); } @Override ProductInfo findOne(String productId); @Override List<ProductInfo> findUpAll(); @Override Page<ProductInfo> findAll(Pageable pageable); @Override ProductInfo save(ProductInfo productInfo); @Override @Transactional void increaseStock(List<CartDTO> cartDTOList); @Override @Transactional void decreaseStock(List<CartDTO> cartDTOList); @Override ProductInfo onSale(String productId); @Override ProductInfo offSale(String productId); }### Answer:
@Test public void findUpAll() throws Exception { List<ProductInfo> productInfoList = productService.findUpAll(); Assert.assertNotEquals(0, productInfoList.size()); } |
### Question:
PayServiceImpl implements PayService { @Override public RefundResponse refund(OrderDTO orderDTO) { RefundRequest refundRequest = new RefundRequest(); refundRequest.setOrderId(orderDTO.getOrderId()); refundRequest.setOrderAmount(orderDTO.getOrderAmount().doubleValue()); refundRequest.setPayTypeEnum(BestPayTypeEnum.WXPAY_H5); log.info("【微信退款】request={}", JsonUtil.toJson(refundRequest)); RefundResponse refundResponse = bestPayService.refund(refundRequest); log.info("【微信退款】response={}", JsonUtil.toJson(refundResponse)); return refundResponse; } @Override PayResponse create(OrderDTO orderDTO); @Override PayResponse notify(String notifyData); @Override RefundResponse refund(OrderDTO orderDTO); }### Answer:
@Test public void refund() { OrderDTO orderDTO = orderService.findOne("1499592887470659070"); payService.refund(orderDTO); } |
### Question:
ProductServiceImpl implements ProductService { @Override public Page<ProductInfo> findAll(Pageable pageable) { return repository.findAll(pageable); } @Override ProductInfo findOne(String productId); @Override List<ProductInfo> findUpAll(); @Override Page<ProductInfo> findAll(Pageable pageable); @Override ProductInfo save(ProductInfo productInfo); @Override @Transactional void increaseStock(List<CartDTO> cartDTOList); @Override @Transactional void decreaseStock(List<CartDTO> cartDTOList); @Override ProductInfo onSale(String productId); @Override ProductInfo offSale(String productId); }### Answer:
@Test public void findAll() throws Exception { PageRequest request = new PageRequest(0, 2); Page<ProductInfo> productInfoPage = productService.findAll(request); Assert.assertNotEquals(0, productInfoPage.getTotalElements()); } |
### Question:
ProductServiceImpl implements ProductService { @Override public ProductInfo save(ProductInfo productInfo) { return repository.save(productInfo); } @Override ProductInfo findOne(String productId); @Override List<ProductInfo> findUpAll(); @Override Page<ProductInfo> findAll(Pageable pageable); @Override ProductInfo save(ProductInfo productInfo); @Override @Transactional void increaseStock(List<CartDTO> cartDTOList); @Override @Transactional void decreaseStock(List<CartDTO> cartDTOList); @Override ProductInfo onSale(String productId); @Override ProductInfo offSale(String productId); }### Answer:
@Test public void save() throws Exception { ProductInfo productInfo = new ProductInfo(); productInfo.setProductId("123457"); productInfo.setProductName("皮皮虾"); productInfo.setProductPrice(new BigDecimal(3.2)); productInfo.setProductStock(100); productInfo.setProductDescription("很好吃的虾"); productInfo.setProductIcon("http: productInfo.setProductStatus(ProductStatusEnum.DOWN.getCode()); productInfo.setCategoryType(2); ProductInfo result = productService.save(productInfo); Assert.assertNotNull(result); } |
### Question:
ProductServiceImpl implements ProductService { @Override public ProductInfo onSale(String productId) { ProductInfo productInfo = repository.findOne(productId); if (productInfo == null) { throw new SellException(ResultEnum.PRODUCT_NOT_EXIST); } if (productInfo.getProductStatusEnum() == ProductStatusEnum.UP) { throw new SellException(ResultEnum.PRODUCT_STATUS_ERROR); } productInfo.setProductStatus(ProductStatusEnum.UP.getCode()); return repository.save(productInfo); } @Override ProductInfo findOne(String productId); @Override List<ProductInfo> findUpAll(); @Override Page<ProductInfo> findAll(Pageable pageable); @Override ProductInfo save(ProductInfo productInfo); @Override @Transactional void increaseStock(List<CartDTO> cartDTOList); @Override @Transactional void decreaseStock(List<CartDTO> cartDTOList); @Override ProductInfo onSale(String productId); @Override ProductInfo offSale(String productId); }### Answer:
@Test public void onSale() { ProductInfo result = productService.onSale("123456"); Assert.assertEquals(ProductStatusEnum.UP, result.getProductStatusEnum()); } |
### Question:
ProductServiceImpl implements ProductService { @Override public ProductInfo offSale(String productId) { ProductInfo productInfo = repository.findOne(productId); if (productInfo == null) { throw new SellException(ResultEnum.PRODUCT_NOT_EXIST); } if (productInfo.getProductStatusEnum() == ProductStatusEnum.DOWN) { throw new SellException(ResultEnum.PRODUCT_STATUS_ERROR); } productInfo.setProductStatus(ProductStatusEnum.DOWN.getCode()); return repository.save(productInfo); } @Override ProductInfo findOne(String productId); @Override List<ProductInfo> findUpAll(); @Override Page<ProductInfo> findAll(Pageable pageable); @Override ProductInfo save(ProductInfo productInfo); @Override @Transactional void increaseStock(List<CartDTO> cartDTOList); @Override @Transactional void decreaseStock(List<CartDTO> cartDTOList); @Override ProductInfo onSale(String productId); @Override ProductInfo offSale(String productId); }### Answer:
@Test public void offSale() { ProductInfo result = productService.offSale("123456"); Assert.assertEquals(ProductStatusEnum.DOWN, result.getProductStatusEnum()); } |
### Question:
SellerServiceImpl implements SellerService { @Override public SellerInfo findSellerInfoByOpenid(String openid) { return repository.findByOpenid(openid); } @Override SellerInfo findSellerInfoByOpenid(String openid); }### Answer:
@Test public void findSellerInfoByOpenid() throws Exception { SellerInfo result = sellerService.findSellerInfoByOpenid(openid); Assert.assertEquals(openid, result.getOpenid()); } |
### Question:
PushMessageServiceImpl implements PushMessageService { @Override public void orderStatus(OrderDTO orderDTO) { WxMpTemplateMessage templateMessage = new WxMpTemplateMessage(); templateMessage.setTemplateId(accountConfig.getTemplateId().get("orderStatus")); templateMessage.setToUser(orderDTO.getBuyerOpenid()); List<WxMpTemplateData> data = Arrays.asList( new WxMpTemplateData("first", "亲，请记得收货。"), new WxMpTemplateData("keyword1", "微信点餐"), new WxMpTemplateData("keyword2", "18868812345"), new WxMpTemplateData("keyword3", orderDTO.getOrderId()), new WxMpTemplateData("keyword4", orderDTO.getOrderStatusEnum().getMessage()), new WxMpTemplateData("keyword5", "￥" + orderDTO.getOrderAmount()), new WxMpTemplateData("remark", "欢迎再次光临！") ); templateMessage.setData(data); try { wxMpService.getTemplateMsgService().sendTemplateMsg(templateMessage); }catch (WxErrorException e) { log.error("【微信模版消息】发送失败, {}", e); } } @Override void orderStatus(OrderDTO orderDTO); }### Answer:
@Test public void orderStatus() throws Exception { OrderDTO orderDTO = orderService.findOne("1499097346204378750"); pushMessageService.orderStatus(orderDTO); } |
### Question:
CategoryServiceImpl implements CategoryService { @Override public ProductCategory findOne(Integer categoryId) { return repository.findOne(categoryId); } @Override ProductCategory findOne(Integer categoryId); @Override List<ProductCategory> findAll(); @Override List<ProductCategory> findByCategoryTypeIn(List<Integer> categoryTypeList); @Override ProductCategory save(ProductCategory productCategory); }### Answer:
@Test public void findOne() throws Exception { ProductCategory productCategory = categoryService.findOne(1); Assert.assertEquals(new Integer(1), productCategory.getCategoryId()); } |
### Question:
CategoryServiceImpl implements CategoryService { @Override public List<ProductCategory> findAll() { return repository.findAll(); } @Override ProductCategory findOne(Integer categoryId); @Override List<ProductCategory> findAll(); @Override List<ProductCategory> findByCategoryTypeIn(List<Integer> categoryTypeList); @Override ProductCategory save(ProductCategory productCategory); }### Answer:
@Test public void findAll() throws Exception { List<ProductCategory> productCategoryList = categoryService.findAll(); Assert.assertNotEquals(0, productCategoryList.size()); } |
### Question:
Util { public static void validateKey(Object key) { notNullArg(key, "Key must not be null."); } private Util(); static int len(Object[] arr); static int len(Collection collection); static int len(Map map); static int len(String str); static boolean empty(String str); static boolean empty(Object[] arr); static boolean empty(Collection collection); static boolean empty(Map map); static boolean empty(char ch); static void validateKey(Object key); static void validateKey(String key); static String obtainValidKey(Class type); static void validateValue(T value, boolean allowNullValues); static void illegalArg(boolean throwIt, String msg); static void illegalState(boolean throwIt, String msg); static void illegalAccess(boolean throwIt, String msg); static void runtimeException(String msg, Throwable thr); static void notNullArg(Object bob, String msg); static void notNull(Object bob, String msg); static void nonEmptyArg(char ch, String msg); static void nonEmptyArg(String str, String msg); static void nonEmptyArg(Object[] arr, String msg); static void nonEmptyArg(Collection collection, String msg); static void nonEmpty(char ch, String msg); static void nonEmpty(String str, String msg); static void nonEmpty(Object[] arr, String msg); static void nonEmpty(Collection collection, String msg); static void nonEmpty(Map map, String msg); @SuppressWarnings("unchecked") static UncheckedFuture<V> unchecked(Future<V> future); static V getUnchecked(Future<V> future); static void pokeball(Throwable pokemon); static void closeSilently(Closeable closeable); @SuppressWarnings("unchecked") static Class<T> checkedClass(T value); static Future<T> present(T result); static ExecutorService newFixedCachedThread(int threads, ThreadFactory threadFactory); @SuppressWarnings("unchecked") static Cache<K, V> newCacheInstance(Class<? extends Cache> imp, CacheOptions opts); }### Answer:
@Test public void testValidStringKeys() { validateKey(GIVEN_KEY); validateKey("m_" + GIVEN_KEY); validateKey("yup"); validateKey("this_is-valid"); validateKey("n4mb3rs"); validateKey("1234567890"); validateKey("-____-"); } |
### Question:
Util { public static int len(Object[] arr) { return empty(arr) ? 0 : arr.length; } private Util(); static int len(Object[] arr); static int len(Collection collection); static int len(Map map); static int len(String str); static boolean empty(String str); static boolean empty(Object[] arr); static boolean empty(Collection collection); static boolean empty(Map map); static boolean empty(char ch); static void validateKey(Object key); static void validateKey(String key); static String obtainValidKey(Class type); static void validateValue(T value, boolean allowNullValues); static void illegalArg(boolean throwIt, String msg); static void illegalState(boolean throwIt, String msg); static void illegalAccess(boolean throwIt, String msg); static void runtimeException(String msg, Throwable thr); static void notNullArg(Object bob, String msg); static void notNull(Object bob, String msg); static void nonEmptyArg(char ch, String msg); static void nonEmptyArg(String str, String msg); static void nonEmptyArg(Object[] arr, String msg); static void nonEmptyArg(Collection collection, String msg); static void nonEmpty(char ch, String msg); static void nonEmpty(String str, String msg); static void nonEmpty(Object[] arr, String msg); static void nonEmpty(Collection collection, String msg); static void nonEmpty(Map map, String msg); @SuppressWarnings("unchecked") static UncheckedFuture<V> unchecked(Future<V> future); static V getUnchecked(Future<V> future); static void pokeball(Throwable pokemon); static void closeSilently(Closeable closeable); @SuppressWarnings("unchecked") static Class<T> checkedClass(T value); static Future<T> present(T result); static ExecutorService newFixedCachedThread(int threads, ThreadFactory threadFactory); @SuppressWarnings("unchecked") static Cache<K, V> newCacheInstance(Class<? extends Cache> imp, CacheOptions opts); }### Answer:
@Test public void testLenArray() { assertEquals(0, Util.len((Object[]) null)); assertEquals(0, Util.len(new Object[]{})); assertEquals(1, Util.len(new Object[]{"hello"})); } |
### Question:
Util { public static boolean empty(String str) { return str == null || str.equals(""); } private Util(); static int len(Object[] arr); static int len(Collection collection); static int len(Map map); static int len(String str); static boolean empty(String str); static boolean empty(Object[] arr); static boolean empty(Collection collection); static boolean empty(Map map); static boolean empty(char ch); static void validateKey(Object key); static void validateKey(String key); static String obtainValidKey(Class type); static void validateValue(T value, boolean allowNullValues); static void illegalArg(boolean throwIt, String msg); static void illegalState(boolean throwIt, String msg); static void illegalAccess(boolean throwIt, String msg); static void runtimeException(String msg, Throwable thr); static void notNullArg(Object bob, String msg); static void notNull(Object bob, String msg); static void nonEmptyArg(char ch, String msg); static void nonEmptyArg(String str, String msg); static void nonEmptyArg(Object[] arr, String msg); static void nonEmptyArg(Collection collection, String msg); static void nonEmpty(char ch, String msg); static void nonEmpty(String str, String msg); static void nonEmpty(Object[] arr, String msg); static void nonEmpty(Collection collection, String msg); static void nonEmpty(Map map, String msg); @SuppressWarnings("unchecked") static UncheckedFuture<V> unchecked(Future<V> future); static V getUnchecked(Future<V> future); static void pokeball(Throwable pokemon); static void closeSilently(Closeable closeable); @SuppressWarnings("unchecked") static Class<T> checkedClass(T value); static Future<T> present(T result); static ExecutorService newFixedCachedThread(int threads, ThreadFactory threadFactory); @SuppressWarnings("unchecked") static Cache<K, V> newCacheInstance(Class<? extends Cache> imp, CacheOptions opts); }### Answer:
@Test public void testEmptyStr() { assertTrue(Util.empty((String) null)); assertTrue(Util.empty("")); assertFalse(Util.empty("something")); assertFalse(Util.empty(" ")); }
@Test public void testEmptyChar() { final char empty = ' '; assertTrue(Util.empty(empty)); assertFalse(Util.empty('e')); } |
### Question:
Present implements Future<T> { @Override public T get() throws InterruptedException, ExecutionException { return mValue; } Present(T value); @Override boolean cancel(boolean b); @Override boolean isCancelled(); @Override boolean isDone(); @Override T get(); @Override T get(long l, TimeUnit timeUnit); }### Answer:
@Test public void presentWithNullGetsNull() throws ExecutionException, InterruptedException { final Present present = new Present(null); Assert.assertEquals(null, present.get()); }
@Test public void presentWithObjGetsObj() throws ExecutionException, InterruptedException { final Object obj = new Object(); Present present = new Present(obj); Assert.assertEquals(obj, present.get()); } |
### Question:
UncheckedFuture implements Future<V> { public V getUnchecked() { try { return get(); } catch (Throwable pokemon) { Util.pokeball(pokemon); } return null; } UncheckedFuture(Future<V> future); @Override boolean cancel(boolean b); @Override boolean isCancelled(); @Override boolean isDone(); @Override V get(); @Override V get(long l, TimeUnit timeUnit); V getUnchecked(); V getUnchecked(long l, TimeUnit timeUnit); }### Answer:
@Test public void getUncheckedWithNullGetsNull() { Assert.assertEquals(null, new UncheckedFuture(null).getUnchecked()); }
@Test public void getUncheckedWithObjGetsObj() { final Object obj = new Object(); final Future<Object> theFutureNow = new TheFutureNow(obj); Assert.assertEquals(obj, new UncheckedFuture(theFutureNow).getUnchecked()); } |
### Question:
UnmodifiableCache implements Cache<K, V> { @Override public UnmodifiableCache<K, V> set(K key, V value) { illegalAccess(true, "You must not try to modify an UnmodifiableCache."); return null; } UnmodifiableCache(Cache<K, V> cache); @Override V get(K key); @Override UnmodifiableCache<K, V> set(K key, V value); }### Answer:
@Test (expected = Throwable.class) public void testUnmodifiableIsUnmodifiable() { final ReferenceCache<Object, Object> notNullCache = gimmeReferenceCacheOfOne(); final UnmodifiableCache<Object, Object> unmodifiable = unmodifiable(notNullCache); unmodifiable.set("something", "here"); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.