Datasets:
Minata
/
512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files
xet
Community
method2testcases
stringlengths
118
3.08k
### Question: SerieSyncNetworkTask extends AsyncTask<Call<TvShow>, Void, SerieDto> { protected void onPostExecute(SerieDto updatedDto) { serieService.updateTmdbInfo(updatedDto, serieReview); } SerieSyncNetworkTask(SerieBuilderFromMovie serieBuilderFromMovie, SerieReview serieReview, SerieService serieService); }### Answer: @Test public void onPostExecute() { SerieDto serieDto = mock(SerieDto.class); SerieReview serieReview = mock(SerieReview.class); new SerieSyncNetworkTask(serieBuilderFromMovie, serieReview, serieService).onPostExecute(serieDto); verify(serieService).updateTmdbInfo(serieDto, serieReview); }
### Question: TmdbServiceWrapper { public Call<MovieResultsPage> search(String name) { initSearchLanguageIfNeeded(); return tmdb.searchService().movie( name, 1, getTmdbPrefLanguage(), null, null, null, null ); } TmdbServiceWrapper(Context context); TmdbServiceWrapper(Tmdb tmdb, Context context, PreferencesWrapper preferencesWrapper, LocaleWrapper localeWrapper); Call<MovieResultsPage> search(String name); Call<TvShowResultsPage> searchTv(String name); List<Integer> tvShowSeasons(int tvShowId); List<TvEpisode> tvShowEpisodes(int tvShowId, List<Integer> tvSeasonNumbers); Call<TvShow> searchTvShowById(int tvShowId); }### Answer: @Test public void searchMovie() throws Exception { doReturn(searchService).when(tmdb).searchService(); doReturn("fr").when(preferencesWrapper).getStringPreference(context, "default_tmdb_language", null); doReturn(call).when(searchService).movie("name", 1, "fr", null, null, null, null); assertEquals( call, new TmdbServiceWrapper(tmdb, context, preferencesWrapper, localeWrapper).search("name") ); }
### Question: TmdbServiceWrapper { public Call<TvShowResultsPage> searchTv(String name) { initSearchLanguageIfNeeded(); return tmdb.searchService().tv( name, 1, getTmdbPrefLanguage(), null ); } TmdbServiceWrapper(Context context); TmdbServiceWrapper(Tmdb tmdb, Context context, PreferencesWrapper preferencesWrapper, LocaleWrapper localeWrapper); Call<MovieResultsPage> search(String name); Call<TvShowResultsPage> searchTv(String name); List<Integer> tvShowSeasons(int tvShowId); List<TvEpisode> tvShowEpisodes(int tvShowId, List<Integer> tvSeasonNumbers); Call<TvShow> searchTvShowById(int tvShowId); }### Answer: @Test public void searchTv() throws Exception { doReturn(searchService).when(tmdb).searchService(); doReturn("fr").when(preferencesWrapper).getStringPreference(context, "default_tmdb_language", null); doReturn(call).when(searchService).tv("name", 1, "fr", null); assertEquals( call, new TmdbServiceWrapper(tmdb, context, preferencesWrapper, localeWrapper).searchTv("name") ); }
### Question: TmdbServiceWrapper { public Call<TvShow> searchTvShowById(int tvShowId) { initSearchLanguageIfNeeded(); return tmdb.tvService().tv(tvShowId, getTmdbPrefLanguage()); } TmdbServiceWrapper(Context context); TmdbServiceWrapper(Tmdb tmdb, Context context, PreferencesWrapper preferencesWrapper, LocaleWrapper localeWrapper); Call<MovieResultsPage> search(String name); Call<TvShowResultsPage> searchTv(String name); List<Integer> tvShowSeasons(int tvShowId); List<TvEpisode> tvShowEpisodes(int tvShowId, List<Integer> tvSeasonNumbers); Call<TvShow> searchTvShowById(int tvShowId); }### Answer: @Test public void searchTvShowById() { doReturn(tvService).when(tmdb).tvService(); doReturn("fr").when(preferencesWrapper).getStringPreference(context, "default_tmdb_language", null); doReturn(call).when(tvService).tv(15, "fr"); assertEquals( call, new TmdbServiceWrapper(tmdb, context, preferencesWrapper, localeWrapper).searchTvShowById(15) ); }
### Question: TmdbServiceWrapper { void initSearchLanguageIfNeeded() { if (getTmdbPrefLanguage() == null) { preferencesWrapper.setStringPreference(context, "default_tmdb_language", localeWrapper.getLanguage()); } } TmdbServiceWrapper(Context context); TmdbServiceWrapper(Tmdb tmdb, Context context, PreferencesWrapper preferencesWrapper, LocaleWrapper localeWrapper); Call<MovieResultsPage> search(String name); Call<TvShowResultsPage> searchTv(String name); List<Integer> tvShowSeasons(int tvShowId); List<TvEpisode> tvShowEpisodes(int tvShowId, List<Integer> tvSeasonNumbers); Call<TvShow> searchTvShowById(int tvShowId); }### Answer: @Test public void initSearchLanguage() throws Exception { doReturn(null).when(preferencesWrapper).getStringPreference(context, "default_tmdb_language", null); LocaleWrapper localeWrapper = mock(LocaleWrapper.class); doReturn("banane").when(localeWrapper).getLanguage(); new TmdbServiceWrapper(tmdb, context, preferencesWrapper, localeWrapper).initSearchLanguageIfNeeded(); verify(preferencesWrapper).setStringPreference(context, "default_tmdb_language", "banane"); }
### Question: SerieDtoToDbBuilder { public Review buildReview(SerieDto serieDto) { return new Review( serieDto.getReviewId(), serieDto.getTitle(), serieDto.getReview_date(), serieDto.getReview(), serieDto.getRating(), serieDto.getMaxRating() ); } Review buildReview(SerieDto serieDto); TmdbSerie buildTmdbSerie(SerieDto serieDto); SerieEpisode buildSerieEpisode(SerieEpisodeDto serieEpisodeDto); }### Answer: @SuppressWarnings("ResultOfMethodCallIgnored") @Test public void build_review() { Date reviewDate = new Date(); doReturn(null).when(serieDto).getReviewId(); doReturn(5f).when(serieDto).getRating(); doReturn(10).when(serieDto).getMaxRating(); doReturn("a review").when(serieDto).getReview(); doReturn("a title").when(serieDto).getTitle(); doReturn(reviewDate).when(serieDto).getReview_date(); Review review = new Review( null, "a title", reviewDate, "a review", 5f, 10 ); assertEquals( review, new SerieDtoToDbBuilder().buildReview(serieDto) ); }
### Question: SerieDtoToDbBuilder { public TmdbSerie buildTmdbSerie(SerieDto serieDto) { if (serieDto.getTmdbKinoId() != null) { return new TmdbSerie( serieDto.getTmdbKinoId(), serieDto.getPosterPath(), serieDto.getOverview(), serieDto.getYear(), serieDto.getReleaseDate() ); } else { return null; } } Review buildReview(SerieDto serieDto); TmdbSerie buildTmdbSerie(SerieDto serieDto); SerieEpisode buildSerieEpisode(SerieEpisodeDto serieEpisodeDto); }### Answer: @SuppressWarnings("ResultOfMethodCallIgnored") @Test public void build_tmdbserie() { doReturn(4564321L).when(serieDto).getTmdbKinoId();; doReturn("an overview").when(serieDto).getOverview(); doReturn("a poster path").when(serieDto).getPosterPath(); doReturn("a release date").when(serieDto).getReleaseDate(); doReturn(1456).when(serieDto).getYear(); TmdbSerie tmdbSerie = new TmdbSerie( 4564321L, "a poster path", "an overview", 1456, "a release date" ); assertEquals( tmdbSerie, new SerieDtoToDbBuilder().buildTmdbSerie(serieDto) ); } @SuppressWarnings("ResultOfMethodCallIgnored") @Test public void build_tmdbserie_nullId() { doReturn(null).when(serieDto).getTmdbKinoId(); assertNull(new SerieDtoToDbBuilder().buildTmdbSerie(serieDto)); }
### Question: BusinessPreferenceGetter { public boolean getAutomaticExport() { return preferencesWrapper.getBooleanPreference(context, "automatic_save", false); } BusinessPreferenceGetter(Context context); BusinessPreferenceGetter(Context context, PreferencesWrapper preferencesWrapper); boolean getAutomaticExport(); }### Answer: @Test public void getAutomaticExport() { doReturn(true).when(preferencesWrapper).getBooleanPreference(context, "automatic_save", false); assertTrue(new BusinessPreferenceGetter(context, preferencesWrapper).getAutomaticExport()); }
### Question: WishlistItemDeleter { public void deleteWishlistItem(Long tmdbKinoId, String type) { if("kino".equals(type)){ WishlistDataDto byTmdbId = movieWishlistService.getById(tmdbKinoId); movieWishlistService.delete(byTmdbId); } else { WishlistDataDto byTmdbId = serieWishlistService.getById(tmdbKinoId); serieWishlistService.delete(byTmdbId); } } WishlistItemDeleter(Context context); WishlistItemDeleter(SerieWishlistService serieWishlistService, MovieWishlistService movieWishlistService); void deleteWishlistItem(Long tmdbKinoId, String type); }### Answer: @Test public void deleteWishlistMovieItem() { doReturn(wishlistDataDto).when(movieWishlistService).getById(1564L); new WishlistItemDeleter(serieWishlistService, movieWishlistService).deleteWishlistItem(1564L, "kino"); verify(movieWishlistService).delete(wishlistDataDto); } @Test public void deleteWishlistSerieItem() { doReturn(wishlistDataDto).when(serieWishlistService).getById(1564L); new WishlistItemDeleter(serieWishlistService, movieWishlistService).deleteWishlistItem(1564L, "serie"); verify(serieWishlistService).delete(wishlistDataDto); }
### Question: LocalKinoRepository extends CrudRepository<LocalKinoDao, LocalKino> { public LocalKino findByMovieId(long movieId) { Query<LocalKino> localKinoQuery = dao.queryBuilder() .where(LocalKinoDao.Properties.Tmdb_id.eq(movieId)) .limit(1) .build(); List<LocalKino> localKinos = localKinoQuery.list(); return localKinos != null && localKinos.size() > 0 ? localKinos.get(0) : null; } LocalKinoRepository(DaoSession daoSession); LocalKino findByMovieId(long movieId); List<LocalKino> findAllByRating(boolean asc); List<LocalKino> findAllByYear(boolean asc); List<LocalKino> findAllByReviewDate(boolean asc); List<LocalKino> findAllByTitle(final boolean asc); }### Answer: @Test public void findByMovieId() { QueryBuilder queryBuilder = mock(QueryBuilder.class); doReturn(queryBuilder).when(localKinoDao).queryBuilder(); doReturn(queryBuilder).when(queryBuilder).where(any(WhereCondition.class)); doReturn(queryBuilder).when(queryBuilder).limit(1); Query query = mock(Query.class); doReturn(query).when(queryBuilder).build(); doReturn(Arrays.asList(localKino)).when(query).list(); assertEquals( localKino, new LocalKinoRepository(daoSession).findByMovieId(45) ); }
### Question: SerieWishlistService implements WishlistService { public List<WishlistDataDto> getAll() { List<WishlistSerie> wishlistSeries = wishlistSerieRepository.findAll(); List<WishlistDataDto> serieDataDtos = new ArrayList<>(); for (WishlistSerie wishlistSerie : wishlistSeries) { serieDataDtos.add(wishlistSerieToSerieDataDtoBuilder.build(wishlistSerie)); } return serieDataDtos; } SerieWishlistService(DaoSession daoSession); SerieWishlistService(WishlistSerieRepository wishlistSerieRepository, TmdbSerieRepository tmdbSerieRepository, WishlistSerieToSerieDataDtoBuilder wishlistSerieToSerieDataDtoBuilder); void createSerieData(WishlistDataDto wishlistDataDto); List<WishlistDataDto> getAll(); void delete(WishlistDataDto wishlistDataDto); @Override WishlistDataDto getByTmdbId(Integer id); @Override WishlistDataDto getById(Long id); @Override WishlistDataDto getWithTmdbId(long tmdbId); @Override WishlistDataDto createOrUpdate(WishlistDataDto dtoObject); @Override void createOrUpdateWithTmdbId(List<WishlistDataDto> dtos); }### Answer: @Test public void getAll() { final WishlistSerie wishlistSerie = mock(WishlistSerie.class); doReturn(new ArrayList<WishlistSerie>(){{add(wishlistSerie);}}).when(wishlistSerieRepository).findAll(); final WishlistDataDto wishlistDataDto = mock(WishlistDataDto.class); doReturn(wishlistDataDto).when(wishlistSerieToSerieDataDtoBuilder).build(wishlistSerie); assertEquals( new ArrayList<WishlistDataDto>() {{ add(wishlistDataDto); }}, new SerieWishlistService(wishlistSerieRepository, tmdbSerieRepository, wishlistSerieToSerieDataDtoBuilder).getAll() ); }
### Question: SerieWishlistService implements WishlistService { @Override public WishlistDataDto getById(Long id) { WishlistSerie wishlistSerie = wishlistSerieRepository.find(id); return wishlistSerie != null ? wishlistSerieToSerieDataDtoBuilder.build(wishlistSerie) : null; } SerieWishlistService(DaoSession daoSession); SerieWishlistService(WishlistSerieRepository wishlistSerieRepository, TmdbSerieRepository tmdbSerieRepository, WishlistSerieToSerieDataDtoBuilder wishlistSerieToSerieDataDtoBuilder); void createSerieData(WishlistDataDto wishlistDataDto); List<WishlistDataDto> getAll(); void delete(WishlistDataDto wishlistDataDto); @Override WishlistDataDto getByTmdbId(Integer id); @Override WishlistDataDto getById(Long id); @Override WishlistDataDto getWithTmdbId(long tmdbId); @Override WishlistDataDto createOrUpdate(WishlistDataDto dtoObject); @Override void createOrUpdateWithTmdbId(List<WishlistDataDto> dtos); }### Answer: @Test public void getById() { final WishlistSerie wishlistSerie = mock(WishlistSerie.class); doReturn(wishlistSerie).when(wishlistSerieRepository).find(34455L); final WishlistDataDto wishlistDataDto = mock(WishlistDataDto.class); doReturn(wishlistDataDto).when(wishlistSerieToSerieDataDtoBuilder).build(wishlistSerie); assertEquals( wishlistDataDto, new SerieWishlistService(wishlistSerieRepository, tmdbSerieRepository, wishlistSerieToSerieDataDtoBuilder).getById(34455L) ); }
### Question: SerieWishlistService implements WishlistService { public void delete(WishlistDataDto wishlistDataDto) { wishlistSerieRepository.delete(wishlistDataDto.getId()); } SerieWishlistService(DaoSession daoSession); SerieWishlistService(WishlistSerieRepository wishlistSerieRepository, TmdbSerieRepository tmdbSerieRepository, WishlistSerieToSerieDataDtoBuilder wishlistSerieToSerieDataDtoBuilder); void createSerieData(WishlistDataDto wishlistDataDto); List<WishlistDataDto> getAll(); void delete(WishlistDataDto wishlistDataDto); @Override WishlistDataDto getByTmdbId(Integer id); @Override WishlistDataDto getById(Long id); @Override WishlistDataDto getWithTmdbId(long tmdbId); @Override WishlistDataDto createOrUpdate(WishlistDataDto dtoObject); @Override void createOrUpdateWithTmdbId(List<WishlistDataDto> dtos); }### Answer: @Test public void delete() { final WishlistDataDto wishlistDataDto = mock(WishlistDataDto.class); doReturn(345L).when(wishlistDataDto).getId(); new SerieWishlistService(wishlistSerieRepository, tmdbSerieRepository, wishlistSerieToSerieDataDtoBuilder).delete(wishlistDataDto); verify(wishlistSerieRepository).delete(345L); }
### Question: MovieWishlistService implements WishlistService { public List<WishlistDataDto> getAll() { List<WishlistMovie> wishlistMovies = wishlistMovieRepository.findAll(); List<WishlistDataDto> serieDataDtos = new ArrayList<>(); for (WishlistMovie wishlistMovie : wishlistMovies) { serieDataDtos.add(wishlistMovieToSerieDataDtoBuilder.build(wishlistMovie)); } return serieDataDtos; } MovieWishlistService(DaoSession daoSession); MovieWishlistService(WishlistMovieRepository wishlistMovieRepository, TmdbKinoRepository tmdbKinoRepository, WishlistMovieToSerieDataDtoBuilder wishlistMovieToSerieDataDtoBuilder); void createMovieData(WishlistDataDto wishlistDataDto); List<WishlistDataDto> getAll(); void delete(WishlistDataDto wishlistDataDto); @Override WishlistDataDto getByTmdbId(Integer id); @Override WishlistDataDto getById(Long id); @Override WishlistDataDto getWithTmdbId(long tmdbId); @Override WishlistDataDto createOrUpdate(WishlistDataDto dtoObject); @Override void createOrUpdateWithTmdbId(List<WishlistDataDto> dtos); }### Answer: @Test public void getAll() { final WishlistMovie wishlistMovie = mock(WishlistMovie.class); doReturn(new ArrayList<WishlistMovie>(){{add(wishlistMovie);}}).when(wishlistMovieRepository).findAll(); final WishlistDataDto wishlistDataDto = mock(WishlistDataDto.class); doReturn(wishlistDataDto).when(wishlistMovieToSerieDataDtoBuilder).build(wishlistMovie); assertEquals( new ArrayList<WishlistDataDto>() {{ add(wishlistDataDto); }}, new MovieWishlistService(wishlistMovieRepository, tmdbKinoRepository, wishlistMovieToSerieDataDtoBuilder).getAll() ); }
### Question: MovieWishlistService implements WishlistService { @Override public WishlistDataDto getById(Long id) { WishlistMovie wishlistMovie = wishlistMovieRepository.find(id); return wishlistMovie != null ? wishlistMovieToSerieDataDtoBuilder.build(wishlistMovie) : null; } MovieWishlistService(DaoSession daoSession); MovieWishlistService(WishlistMovieRepository wishlistMovieRepository, TmdbKinoRepository tmdbKinoRepository, WishlistMovieToSerieDataDtoBuilder wishlistMovieToSerieDataDtoBuilder); void createMovieData(WishlistDataDto wishlistDataDto); List<WishlistDataDto> getAll(); void delete(WishlistDataDto wishlistDataDto); @Override WishlistDataDto getByTmdbId(Integer id); @Override WishlistDataDto getById(Long id); @Override WishlistDataDto getWithTmdbId(long tmdbId); @Override WishlistDataDto createOrUpdate(WishlistDataDto dtoObject); @Override void createOrUpdateWithTmdbId(List<WishlistDataDto> dtos); }### Answer: @Test public void getById() { final WishlistMovie wishlistMovie = mock(WishlistMovie.class); doReturn(wishlistMovie).when(wishlistMovieRepository).find(34455L); final WishlistDataDto wishlistDataDto = mock(WishlistDataDto.class); doReturn(wishlistDataDto).when(wishlistMovieToSerieDataDtoBuilder).build(wishlistMovie); assertEquals( wishlistDataDto, new MovieWishlistService(wishlistMovieRepository, tmdbKinoRepository, wishlistMovieToSerieDataDtoBuilder).getById(34455L) ); }
### Question: MovieWishlistService implements WishlistService { public void delete(WishlistDataDto wishlistDataDto) { wishlistMovieRepository.delete(wishlistDataDto.getId()); } MovieWishlistService(DaoSession daoSession); MovieWishlistService(WishlistMovieRepository wishlistMovieRepository, TmdbKinoRepository tmdbKinoRepository, WishlistMovieToSerieDataDtoBuilder wishlistMovieToSerieDataDtoBuilder); void createMovieData(WishlistDataDto wishlistDataDto); List<WishlistDataDto> getAll(); void delete(WishlistDataDto wishlistDataDto); @Override WishlistDataDto getByTmdbId(Integer id); @Override WishlistDataDto getById(Long id); @Override WishlistDataDto getWithTmdbId(long tmdbId); @Override WishlistDataDto createOrUpdate(WishlistDataDto dtoObject); @Override void createOrUpdateWithTmdbId(List<WishlistDataDto> dtos); }### Answer: @Test public void delete() { final WishlistDataDto wishlistDataDto = mock(WishlistDataDto.class); doReturn(345L).when(wishlistDataDto).getId(); new MovieWishlistService(wishlistMovieRepository, tmdbKinoRepository, wishlistMovieToSerieDataDtoBuilder).delete(wishlistDataDto); verify(wishlistMovieRepository).delete(345L); }
### Question: SerieService implements DataService<SerieDto> { public SerieDto getReview(long id) { SerieReview review = serieReviewRepository.find(id); return serieKinoDtoBuilder.build(review); } SerieService(SerieReviewRepository serieReviewRepository, ReviewRepository reviewRepository, TmdbSerieRepository tmdbSerieRepository, TmdbGetterService tmdbGetterService, SerieKinoDtoBuilder serieKinoDtoBuilder, SerieDtoToDbBuilder dtoToDbBuilder); SerieService(DaoSession daoSession, Context context); SerieDto getReview(long id); SerieDto getWithTmdbId(long movieId); @Override void delete(SerieDto serieDto); @Override SerieDto createOrUpdate(SerieDto serieDto); @Override void createOrUpdateWithTmdbId(List<SerieDto> serieDtos); void syncWithTmdb(long tmdbId); void updateTmdbInfo(SerieDto updatedDto, SerieReview serieReview); List<SerieDto> getAll(); List<SerieDto> getAllByRating(boolean asc); List<SerieDto> getAllByTitle(boolean asc); }### Answer: @Test public void getReview() { SerieReview serieReview = mock(SerieReview.class); doReturn(serieReview).when(serieReviewRepository).find(4L); doReturn(serieDto).when(serieKinoDtoBuilder).build(serieReview); assertEquals( serieDto, new SerieService(serieReviewRepository, reviewRepository, tmdbSerieRepository, tmdbGetterService, serieKinoDtoBuilder, toDbBuilder).getReview(4L) ); }
### Question: SerieService implements DataService<SerieDto> { public SerieDto getWithTmdbId(long movieId) { SerieReview review = serieReviewRepository.findByMovieId(movieId); return review != null ? serieKinoDtoBuilder.build(review) : null; } SerieService(SerieReviewRepository serieReviewRepository, ReviewRepository reviewRepository, TmdbSerieRepository tmdbSerieRepository, TmdbGetterService tmdbGetterService, SerieKinoDtoBuilder serieKinoDtoBuilder, SerieDtoToDbBuilder dtoToDbBuilder); SerieService(DaoSession daoSession, Context context); SerieDto getReview(long id); SerieDto getWithTmdbId(long movieId); @Override void delete(SerieDto serieDto); @Override SerieDto createOrUpdate(SerieDto serieDto); @Override void createOrUpdateWithTmdbId(List<SerieDto> serieDtos); void syncWithTmdb(long tmdbId); void updateTmdbInfo(SerieDto updatedDto, SerieReview serieReview); List<SerieDto> getAll(); List<SerieDto> getAllByRating(boolean asc); List<SerieDto> getAllByTitle(boolean asc); }### Answer: @Test public void getByTmdbMovieId() { SerieReview serieReview = mock(SerieReview.class); doReturn(serieReview).when(serieReviewRepository).findByMovieId(4L); doReturn(serieDto).when(serieKinoDtoBuilder).build(serieReview); assertEquals( serieDto, new SerieService(serieReviewRepository, reviewRepository, tmdbSerieRepository, tmdbGetterService, serieKinoDtoBuilder, toDbBuilder).getWithTmdbId(4L) ); }
### Question: SerieService implements DataService<SerieDto> { public List<SerieDto> getAll() { return buildKinos(serieReviewRepository.findAll()); } SerieService(SerieReviewRepository serieReviewRepository, ReviewRepository reviewRepository, TmdbSerieRepository tmdbSerieRepository, TmdbGetterService tmdbGetterService, SerieKinoDtoBuilder serieKinoDtoBuilder, SerieDtoToDbBuilder dtoToDbBuilder); SerieService(DaoSession daoSession, Context context); SerieDto getReview(long id); SerieDto getWithTmdbId(long movieId); @Override void delete(SerieDto serieDto); @Override SerieDto createOrUpdate(SerieDto serieDto); @Override void createOrUpdateWithTmdbId(List<SerieDto> serieDtos); void syncWithTmdb(long tmdbId); void updateTmdbInfo(SerieDto updatedDto, SerieReview serieReview); List<SerieDto> getAll(); List<SerieDto> getAllByRating(boolean asc); List<SerieDto> getAllByTitle(boolean asc); }### Answer: @Test public void getAll() { final SerieReview serieReview = mock(SerieReview.class); doReturn(new ArrayList<SerieReview>() {{ add(serieReview); }}).when(serieReviewRepository).findAll(); doReturn(serieDto).when(serieKinoDtoBuilder).build(serieReview); assertEquals( new ArrayList<SerieDto>() {{ add(serieDto); }}, new SerieService(serieReviewRepository, reviewRepository, tmdbSerieRepository, tmdbGetterService, serieKinoDtoBuilder, toDbBuilder).getAll() ); }
### Question: SerieService implements DataService<SerieDto> { @Override public void delete(SerieDto serieDto) { serieReviewRepository.delete(serieDto.getKinoId()); } SerieService(SerieReviewRepository serieReviewRepository, ReviewRepository reviewRepository, TmdbSerieRepository tmdbSerieRepository, TmdbGetterService tmdbGetterService, SerieKinoDtoBuilder serieKinoDtoBuilder, SerieDtoToDbBuilder dtoToDbBuilder); SerieService(DaoSession daoSession, Context context); SerieDto getReview(long id); SerieDto getWithTmdbId(long movieId); @Override void delete(SerieDto serieDto); @Override SerieDto createOrUpdate(SerieDto serieDto); @Override void createOrUpdateWithTmdbId(List<SerieDto> serieDtos); void syncWithTmdb(long tmdbId); void updateTmdbInfo(SerieDto updatedDto, SerieReview serieReview); List<SerieDto> getAll(); List<SerieDto> getAllByRating(boolean asc); List<SerieDto> getAllByTitle(boolean asc); }### Answer: @Test public void delete() { doReturn(545L).when(serieDto).getKinoId(); new SerieService(serieReviewRepository, reviewRepository, tmdbSerieRepository, tmdbGetterService, serieKinoDtoBuilder, toDbBuilder).delete(serieDto); verify(serieReviewRepository).delete(545L); }
### Question: SerieService implements DataService<SerieDto> { public void syncWithTmdb(long tmdbId) { SerieReview serieReview = serieReviewRepository.findByMovieId(tmdbId); tmdbGetterService.startSyncWithTmdb(this, serieReview, tmdbId); } SerieService(SerieReviewRepository serieReviewRepository, ReviewRepository reviewRepository, TmdbSerieRepository tmdbSerieRepository, TmdbGetterService tmdbGetterService, SerieKinoDtoBuilder serieKinoDtoBuilder, SerieDtoToDbBuilder dtoToDbBuilder); SerieService(DaoSession daoSession, Context context); SerieDto getReview(long id); SerieDto getWithTmdbId(long movieId); @Override void delete(SerieDto serieDto); @Override SerieDto createOrUpdate(SerieDto serieDto); @Override void createOrUpdateWithTmdbId(List<SerieDto> serieDtos); void syncWithTmdb(long tmdbId); void updateTmdbInfo(SerieDto updatedDto, SerieReview serieReview); List<SerieDto> getAll(); List<SerieDto> getAllByRating(boolean asc); List<SerieDto> getAllByTitle(boolean asc); }### Answer: @SuppressWarnings("ResultOfMethodCallIgnored") @Test public void syncSerieWithTmdb() { SerieReview serieReview = mock(SerieReview.class); doReturn(serieReview).when(serieReviewRepository).findByMovieId(24); SerieService serieService = new SerieService(serieReviewRepository, reviewRepository, tmdbSerieRepository, tmdbGetterService, serieKinoDtoBuilder, toDbBuilder); serieService.syncWithTmdb(24); verify(tmdbGetterService).startSyncWithTmdb(serieService, serieReview, 24); }
### Question: KinoService implements DataService<KinoDto> { public KinoDto getKino(long id) { LocalKino kino = localKinoRepository.find(id); return kinoDtoBuilder.build(kino); } KinoService(DaoSession session); KinoService(LocalKinoRepository localKinoRepository, TmdbKinoRepository tmdbKinoRepository, KinoDtoBuilder kinoDtoBuilder, KinoDtoToDbBuilder builder); KinoDto getKino(long id); List<KinoDto> getAll(); void createOrUpdateWithTmdbId(List<KinoDto> kinoDtos); KinoDto createOrUpdate(KinoDto kinoDto); KinoDto getWithTmdbId(long tmdbId); List<KinoDto> getKinosByRating(boolean asc); List<KinoDto> getKinosByYear(boolean asc); List<KinoDto> getKinosByReviewDate(boolean asc); List<KinoDto> getKinosByTitle(boolean asc); void delete(KinoDto kinoDto); }### Answer: @Test public void getKino() throws Exception { LocalKino localKino = mock(LocalKino.class); doReturn(localKino).when(localKinoRepository).find(4L); doReturn(kinoDto).when(kinoDtoBuilder).build(localKino); assertEquals( kinoDto, new KinoService(localKinoRepository, tmdbKinoRepository, kinoDtoBuilder, null).getKino(4L) ); }
### Question: KinoService implements DataService<KinoDto> { public KinoDto getWithTmdbId(long tmdbId) { LocalKino byMovieId = localKinoRepository.findByMovieId(tmdbId); return byMovieId != null ? kinoDtoBuilder.build(byMovieId) : null; } KinoService(DaoSession session); KinoService(LocalKinoRepository localKinoRepository, TmdbKinoRepository tmdbKinoRepository, KinoDtoBuilder kinoDtoBuilder, KinoDtoToDbBuilder builder); KinoDto getKino(long id); List<KinoDto> getAll(); void createOrUpdateWithTmdbId(List<KinoDto> kinoDtos); KinoDto createOrUpdate(KinoDto kinoDto); KinoDto getWithTmdbId(long tmdbId); List<KinoDto> getKinosByRating(boolean asc); List<KinoDto> getKinosByYear(boolean asc); List<KinoDto> getKinosByReviewDate(boolean asc); List<KinoDto> getKinosByTitle(boolean asc); void delete(KinoDto kinoDto); }### Answer: @Test public void getKinoByTmdbMovieId() throws Exception { LocalKino localKino = mock(LocalKino.class); doReturn(localKino).when(localKinoRepository).findByMovieId(4L); doReturn(kinoDto).when(kinoDtoBuilder).build(localKino); assertEquals( kinoDto, new KinoService(localKinoRepository, tmdbKinoRepository, kinoDtoBuilder, null).getWithTmdbId(4L) ); }
### Question: LocalKinoRepository extends CrudRepository<LocalKinoDao, LocalKino> { public List<LocalKino> findAllByRating(boolean asc) { return queryOrderBy(asc, LocalKinoDao.Properties.Rating); } LocalKinoRepository(DaoSession daoSession); LocalKino findByMovieId(long movieId); List<LocalKino> findAllByRating(boolean asc); List<LocalKino> findAllByYear(boolean asc); List<LocalKino> findAllByReviewDate(boolean asc); List<LocalKino> findAllByTitle(final boolean asc); }### Answer: @Test public void findAllByRatingAsc() { QueryBuilder queryBuilder = mock(QueryBuilder.class); doReturn(queryBuilder).when(localKinoDao).queryBuilder(); doReturn(queryBuilder).when(queryBuilder).orderAsc(LocalKinoDao.Properties.Rating); Query query = mock(Query.class); doReturn(query).when(queryBuilder).build(); doReturn(Arrays.asList(localKino)).when(query).list(); assertEquals( Arrays.asList(localKino), new LocalKinoRepository(daoSession).findAllByRating(true) ); } @Test public void findAllByRatingDesc() { QueryBuilder queryBuilder = mock(QueryBuilder.class); doReturn(queryBuilder).when(localKinoDao).queryBuilder(); doReturn(queryBuilder).when(queryBuilder).orderDesc(LocalKinoDao.Properties.Rating); Query query = mock(Query.class); doReturn(query).when(queryBuilder).build(); doReturn(Arrays.asList(localKino)).when(query).list(); assertEquals( Arrays.asList(localKino), new LocalKinoRepository(daoSession).findAllByRating(false) ); }
### Question: KinoService implements DataService<KinoDto> { public List<KinoDto> getAll() { List<LocalKino> localKinos = localKinoRepository.findAll(); return buildKinos(localKinos); } KinoService(DaoSession session); KinoService(LocalKinoRepository localKinoRepository, TmdbKinoRepository tmdbKinoRepository, KinoDtoBuilder kinoDtoBuilder, KinoDtoToDbBuilder builder); KinoDto getKino(long id); List<KinoDto> getAll(); void createOrUpdateWithTmdbId(List<KinoDto> kinoDtos); KinoDto createOrUpdate(KinoDto kinoDto); KinoDto getWithTmdbId(long tmdbId); List<KinoDto> getKinosByRating(boolean asc); List<KinoDto> getKinosByYear(boolean asc); List<KinoDto> getKinosByReviewDate(boolean asc); List<KinoDto> getKinosByTitle(boolean asc); void delete(KinoDto kinoDto); }### Answer: @Test public void getAllKinos() throws Exception { LocalKino localKino = mock(LocalKino.class); LocalKino anotherLocalKino = mock(LocalKino.class); KinoDto anotherKinoDto = mock(KinoDto.class); doReturn(Arrays.asList(localKino, anotherLocalKino)).when(localKinoRepository).findAll(); doReturn(kinoDto).when(kinoDtoBuilder).build(localKino); doReturn(anotherKinoDto).when(kinoDtoBuilder).build(anotherLocalKino); assertEquals( Arrays.asList(kinoDto, anotherKinoDto), new KinoService(localKinoRepository, tmdbKinoRepository, kinoDtoBuilder, null).getAll() ); }
### Question: KinoService implements DataService<KinoDto> { public KinoDto createOrUpdate(KinoDto kinoDto) { LocalKino localKino = kinoDtoToDbBuilder.build(kinoDto); if(kinoDto.getTmdbKinoId() != null) { tmdbKinoRepository.createOrUpdate(localKino.getKino()); } localKinoRepository.createOrUpdate(localKino); return kinoDtoBuilder.build(localKino); } KinoService(DaoSession session); KinoService(LocalKinoRepository localKinoRepository, TmdbKinoRepository tmdbKinoRepository, KinoDtoBuilder kinoDtoBuilder, KinoDtoToDbBuilder builder); KinoDto getKino(long id); List<KinoDto> getAll(); void createOrUpdateWithTmdbId(List<KinoDto> kinoDtos); KinoDto createOrUpdate(KinoDto kinoDto); KinoDto getWithTmdbId(long tmdbId); List<KinoDto> getKinosByRating(boolean asc); List<KinoDto> getKinosByYear(boolean asc); List<KinoDto> getKinosByReviewDate(boolean asc); List<KinoDto> getKinosByTitle(boolean asc); void delete(KinoDto kinoDto); }### Answer: @Test public void createKinoNullTmdb() { LocalKino kinoToCreate = mock(LocalKino.class); KinoDtoToDbBuilder builder = mock(KinoDtoToDbBuilder.class); doReturn(kinoToCreate).when(builder).build(kinoDto); KinoDto createdKino = mock(KinoDto.class); doReturn(createdKino).when(kinoDtoBuilder).build(kinoToCreate); assertEquals( createdKino, new KinoService(localKinoRepository, tmdbKinoRepository, kinoDtoBuilder, builder).createOrUpdate(kinoDto) ); verify(localKinoRepository).createOrUpdate(kinoToCreate); }
### Question: KinoService implements DataService<KinoDto> { public void delete(KinoDto kinoDto) { localKinoRepository.delete(kinoDto.getKinoId()); } KinoService(DaoSession session); KinoService(LocalKinoRepository localKinoRepository, TmdbKinoRepository tmdbKinoRepository, KinoDtoBuilder kinoDtoBuilder, KinoDtoToDbBuilder builder); KinoDto getKino(long id); List<KinoDto> getAll(); void createOrUpdateWithTmdbId(List<KinoDto> kinoDtos); KinoDto createOrUpdate(KinoDto kinoDto); KinoDto getWithTmdbId(long tmdbId); List<KinoDto> getKinosByRating(boolean asc); List<KinoDto> getKinosByYear(boolean asc); List<KinoDto> getKinosByReviewDate(boolean asc); List<KinoDto> getKinosByTitle(boolean asc); void delete(KinoDto kinoDto); }### Answer: @Test public void deleteKino() { doReturn(545L).when(kinoDto).getKinoId(); new KinoService(localKinoRepository, tmdbKinoRepository, kinoDtoBuilder, null).delete(kinoDto); verify(localKinoRepository).delete(545L); }
### Question: TmdbKinoRepository { public void createOrUpdate(TmdbKino tmdbKino) { tmdbKinoDao.insertOrReplace(tmdbKino); } TmdbKinoRepository(DaoSession daoSession); void createOrUpdate(TmdbKino tmdbKino); TmdbKino find(long id); }### Answer: @Test public void create() throws Exception { doReturn(tmdbKinoDao).when(daoSession).getTmdbKinoDao(); new TmdbKinoRepository(daoSession).createOrUpdate(tmdbKino); verify(tmdbKinoDao).insertOrReplace(tmdbKino); }
### Question: TmdbKinoRepository { public TmdbKino find(long id) { return tmdbKinoDao.load(id); } TmdbKinoRepository(DaoSession daoSession); void createOrUpdate(TmdbKino tmdbKino); TmdbKino find(long id); }### Answer: @Test public void find() throws Exception { doReturn(tmdbKinoDao).when(daoSession).getTmdbKinoDao(); doReturn(tmdbKino).when(tmdbKinoDao).load(4L); assertEquals( tmdbKino, new TmdbKinoRepository(daoSession).find(4L) ); }
### Question: ServiceFactory { public DataService create(String type, DaoSession daoSession) { switch (type){ case "kino": return new KinoService(daoSession); case "serie": return new SerieService(daoSession, context); } throw new NullPointerException("Unable to find a service for this type."); } ServiceFactory(Context baseContext); DataService create(String type, DaoSession daoSession); }### Answer: @Test public void kinoService() { assertTrue(new ServiceFactory(context).create("kino", daoSession) instanceof KinoService); } @Test public void serieService() { assertTrue(new ServiceFactory(context).create("serie", daoSession) instanceof SerieService); } @Test(expected = NullPointerException.class) public void unexistingService() { new ServiceFactory(context).create("banane", daoSession); }
### Question: WishlistSerieRepository extends CrudRepository<WishlistSerieDao, WishlistSerie> { public WishlistSerie findByTmdbId(long tmdbId) { Query<WishlistSerie> wishlistSerieQuery = dao.queryBuilder() .where(WishlistSerieDao.Properties.Tmdb_id.eq(tmdbId)) .limit(1) .build(); List<WishlistSerie> wishlistSeries = wishlistSerieQuery.list(); return wishlistSeries != null && wishlistSeries.size() > 0 ? wishlistSeries.get(0) : null; } WishlistSerieRepository(DaoSession daoSession); WishlistSerie findByTmdbId(long tmdbId); }### Answer: @Test public void findBySerieId() { QueryBuilder queryBuilder = mock(QueryBuilder.class); doReturn(queryBuilder).when(wishlistSerieDao).queryBuilder(); doReturn(queryBuilder).when(queryBuilder).where(any(WhereCondition.class)); doReturn(queryBuilder).when(queryBuilder).limit(1); Query query = mock(Query.class); doReturn(query).when(queryBuilder).build(); doReturn(Collections.singletonList(wishlistSerie)).when(query).list(); assertEquals( wishlistSerie, new WishlistSerieRepository(daoSession).findByTmdbId(45) ); }
### Question: WishlistMovieRepository extends CrudRepository<WishlistMovieDao, WishlistMovie> { public WishlistMovie findByTmdbId(long movieId) { Query<WishlistMovie> wishlistMovieQuery = dao.queryBuilder() .where(WishlistMovieDao.Properties.Tmdb_id.eq(movieId)) .limit(1) .build(); List<WishlistMovie> wishlistMovies = wishlistMovieQuery.list(); return wishlistMovies != null && wishlistMovies.size() > 0 ? wishlistMovies.get(0) : null; } WishlistMovieRepository(DaoSession daoSession); WishlistMovie findByTmdbId(long movieId); }### Answer: @Test public void findByMovieId() { QueryBuilder queryBuilder = mock(QueryBuilder.class); doReturn(queryBuilder).when(wishlistMovieDao).queryBuilder(); doReturn(queryBuilder).when(queryBuilder).where(any(WhereCondition.class)); doReturn(queryBuilder).when(queryBuilder).limit(1); Query query = mock(Query.class); doReturn(query).when(queryBuilder).build(); doReturn(Collections.singletonList(wishlistMovie)).when(query).list(); assertEquals( wishlistMovie, new WishlistMovieRepository(daoSession).findByTmdbId(45) ); }
### Question: LocalKinoRepository extends CrudRepository<LocalKinoDao, LocalKino> { public List<LocalKino> findAllByReviewDate(boolean asc) { return queryOrderBy(asc, LocalKinoDao.Properties.Review_date); } LocalKinoRepository(DaoSession daoSession); LocalKino findByMovieId(long movieId); List<LocalKino> findAllByRating(boolean asc); List<LocalKino> findAllByYear(boolean asc); List<LocalKino> findAllByReviewDate(boolean asc); List<LocalKino> findAllByTitle(final boolean asc); }### Answer: @Test public void findAllByReviewDateAsc() { QueryBuilder queryBuilder = mock(QueryBuilder.class); doReturn(queryBuilder).when(localKinoDao).queryBuilder(); doReturn(queryBuilder).when(queryBuilder).orderAsc(LocalKinoDao.Properties.Review_date); Query query = mock(Query.class); doReturn(query).when(queryBuilder).build(); doReturn(Collections.singletonList(localKino)).when(query).list(); assertEquals( Collections.singletonList(localKino), new LocalKinoRepository(daoSession).findAllByReviewDate(true) ); } @Test public void findAllByReviewDateDesc() { QueryBuilder queryBuilder = mock(QueryBuilder.class); doReturn(queryBuilder).when(localKinoDao).queryBuilder(); doReturn(queryBuilder).when(queryBuilder).orderDesc(LocalKinoDao.Properties.Review_date); Query query = mock(Query.class); doReturn(query).when(queryBuilder).build(); doReturn(Collections.singletonList(localKino)).when(query).list(); assertEquals( Collections.singletonList(localKino), new LocalKinoRepository(daoSession).findAllByReviewDate(false) ); }
### Question: SerieReviewRepository extends CrudRepository<SerieReviewDao, SerieReview> { public SerieReview findByMovieId(long movieId) { Query<SerieReview> serieReviewQuery = dao.queryBuilder() .where(SerieReviewDao.Properties.Tmdb_id.eq(movieId)) .limit(1) .build(); List<SerieReview> serieReviews = serieReviewQuery.list(); return serieReviews != null && serieReviews.size() > 0 ? serieReviews.get(0) : null; } SerieReviewRepository(DaoSession daoSession); SerieReview findByMovieId(long movieId); List<SerieReview> findAllByRating(boolean asc); List<SerieReview> findAllByTitle(boolean asc); }### Answer: @Test public void findByMovieId() { QueryBuilder queryBuilder = mock(QueryBuilder.class); doReturn(queryBuilder).when(serieReviewDao).queryBuilder(); doReturn(queryBuilder).when(queryBuilder).where(any(WhereCondition.class)); doReturn(queryBuilder).when(queryBuilder).limit(1); Query query = mock(Query.class); doReturn(query).when(queryBuilder).build(); doReturn(Collections.singletonList(serieReview)).when(query).list(); assertEquals( serieReview, new SerieReviewRepository(daoSession).findByMovieId(45) ); }
### Question: CsvImporter { @SuppressWarnings("WeakerAccess") public void importCsvFile(String importFilename) throws ImportException { FileReader fileReader; try { fileReader = fileReaderGetter.get(importFilename); } catch (IOException e) { throw new ImportException(context.getString(R.string.import_io_error_toast, importFilename), e); } List<Dto> kinos = dtoImportCreator.getKinos(fileReader); dataService.createOrUpdateWithTmdbId(kinos); } CsvImporter(FileReaderGetter fileReaderGetter, DtoImportCreator<Dto> dtoImportCreator, DataService<Dto> dataService, Context context); @SuppressWarnings("WeakerAccess") void importCsvFile(String importFilename); }### Answer: @Test public void importCsvFile() throws Exception { doReturn(fileReader).when(fileReaderGetter).get("import.csv"); doReturn(new ArrayList<KinoDto>() {{ add(aLocalKino); add(anotherLocalKino); }}).when(dtoImportCreator).getKinos(fileReader); new CsvImporter(fileReaderGetter, dtoImportCreator, kinoService, context).importCsvFile("import.csv"); verify(kinoService).createOrUpdateWithTmdbId(new ArrayList<KinoDto>() {{ add(aLocalKino); add(anotherLocalKino); }}); }
### Question: DtoImportCreator { List<Dto> getKinos(FileReader fileReader) throws ImportException { Iterable<CSVRecord> csvRecords; try { csvRecords = csvFormatWrapper.parse(fileReader); } catch (IOException e) { throw new ImportException(context.getString(R.string.import_parsing_error_toast), e); } List<Dto> kinos = new ArrayList<>(); for (CSVRecord csvRecord : csvRecords) { kinos.add(dtoFromRecordBuilder.build(csvRecord)); } return kinos; } DtoImportCreator(Context context, DtoFromRecordBuilder<Dto> builder); DtoImportCreator(CSVFormatWrapper csvFormatWrapper, DtoFromRecordBuilder<Dto> dtoFromRecordBuilder, Context context); }### Answer: @Test public void getKinos() throws Exception { doReturn(new ArrayList<CSVRecord>() {{ add(record); }}).when(csvFormatWrapper).parse(fileReader); doReturn(kinoDto).when(kinoDtoFromRecordBuilder).build(record); assertEquals( Collections.singletonList(kinoDto), new DtoImportCreator(csvFormatWrapper, kinoDtoFromRecordBuilder, context).getKinos(fileReader) ); } @Test(expected = ImportException.class) public void getKinos_ioException_onWrapper() throws Exception { doThrow(new IOException()).when(csvFormatWrapper).parse(fileReader); assertEquals( Collections.singletonList(kinoDto), new DtoImportCreator(csvFormatWrapper, kinoDtoFromRecordBuilder, context).getKinos(fileReader) ); }
### Question: CsvExporter { public void export() throws IOException { List<T> localKinoList = service.getAll(); for (T dto : localKinoList) { csvExportWriter.write(dto); } csvExportWriter.endWriting(); } CsvExporter(DataService<T> service, CsvExportWriter<T> csvExportWriter); void export(); }### Answer: @Test public void export() throws Exception { final KinoDto aKino = mock(KinoDto.class); final KinoDto anotherKino = mock(KinoDto.class); ArrayList<KinoDto> kinos = new ArrayList<KinoDto>() {{ add(aKino); add(anotherKino); }}; doReturn(kinos).when(kinoService).getAll(); new CsvExporter(kinoService, csvExportWriter).export(); verify(csvExportWriter).write(aKino); verify(csvExportWriter).write(anotherKino); verify(csvExportWriter).endWriting(); }
### Question: ExportTreeManager { void prepareTree() { File root = fileUtilsWrapper.getCineLogRoot(); createIfNotExist(String.format("%s/saves/%s", root.getAbsolutePath(), subDir)); } ExportTreeManager(String subDir); ExportTreeManager(FileUtilsWrapper fileUtilsWrapper, String subDir); }### Answer: @Test public void prepareTreeCreateDirs() { doReturn(externalRoot).when(fileUtilsWrapper).getCineLogRoot(); doReturn("/root/CineLog").when(externalRoot).getAbsolutePath(); File movieCinelogSaves = mock(File.class); doReturn(movieCinelogSaves).when(fileUtilsWrapper).getFile("/root/CineLog/saves/movie"); doReturn(false).when(movieCinelogSaves).exists(); new ExportTreeManager(fileUtilsWrapper, "movie").prepareTree(); verify(movieCinelogSaves).mkdirs(); } @Test public void prepareTreeDoNotCreate() { doReturn(externalRoot).when(fileUtilsWrapper).getCineLogRoot(); doReturn("/root/CineLog").when(externalRoot).getAbsolutePath(); File movieCinelogSaves = mock(File.class); doReturn(movieCinelogSaves).when(fileUtilsWrapper).getFile("/root/CineLog/saves/movie"); doReturn(true).when(movieCinelogSaves).exists(); new ExportTreeManager(fileUtilsWrapper, "movie").prepareTree(); verify(movieCinelogSaves, never()).mkdirs(); }
### Question: ExportTreeManager { boolean isExportNeeded() { return !fileUtilsWrapper.getFile(buildExportFilePath(subDir)).exists(); } ExportTreeManager(String subDir); ExportTreeManager(FileUtilsWrapper fileUtilsWrapper, String subDir); }### Answer: @Test public void isExportNeededTrue() { doReturn(externalRoot).when(fileUtilsWrapper).getCineLogRoot(); doReturn("/root/CineLog").when(externalRoot).getAbsolutePath(); File file = mock(File.class); String path = "/root/CineLog/saves/movie/export" + new SimpleDateFormat("yyyyMMdd").format(new Date()) + ".csv"; doReturn(file).when(fileUtilsWrapper).getFile(path); doReturn(false).when(file).exists(); assertTrue(new ExportTreeManager(fileUtilsWrapper, "movie").isExportNeeded()); } @Test public void isExportNeededFalse() { doReturn(externalRoot).when(fileUtilsWrapper).getCineLogRoot(); doReturn("/root/CineLog").when(externalRoot).getAbsolutePath(); File file = mock(File.class); String path = "/root/CineLog/saves/movie/export" + new SimpleDateFormat("yyyyMMdd").format(new Date()) + ".csv"; doReturn(file).when(fileUtilsWrapper).getFile(path); doReturn(true).when(file).exists(); assertFalse(new ExportTreeManager(fileUtilsWrapper, "movie").isExportNeeded()); }
### Question: ExportTreeManager { FileWriter getNextExportFile() throws IOException { return fileUtilsWrapper.getFileWriter(new File(buildExportFilePath(subDir))); } ExportTreeManager(String subDir); ExportTreeManager(FileUtilsWrapper fileUtilsWrapper, String subDir); }### Answer: @Test public void getNextExportFile() throws IOException { doReturn(externalRoot).when(fileUtilsWrapper).getCineLogRoot(); doReturn("/root/CineLog").when(externalRoot).getAbsolutePath(); String path = "/root/CineLog/saves/movie/export" + new SimpleDateFormat("yyyyMMdd").format(new Date()) + ".csv"; FileWriter fileWriter = mock(FileWriter.class); doReturn(fileWriter).when(fileUtilsWrapper).getFileWriter(new File(path)); assertEquals( fileWriter, new ExportTreeManager(fileUtilsWrapper, "movie").getNextExportFile() ); }
### Question: MainViewModel extends ActorViewModel { @Command(MSG_SEARCH_FOR_CITY_RESULT) void onSearchForCityResult(Optional<City> foundCity) { foundCity.map(this::addNewFavoriteCityAndSaveToPreferences) .defaultIfEmpty(false) .whenNot(Boolean::booleanValue) .then(searchForCityFailure::onNext) .invoke(() -> searchCityInProgress.onNext(false)); } @SuppressLint("RestrictedApi") MainViewModel(); @RestrictTo(TESTS) MainViewModel(Scheduler scheduler); void onCleared(); }### Answer: @Test public void onSearchForCityResultWithValidResultThenHideProgress() { boolean[] result = {false}; viewModel.searchCityInProgress .subscribeOn(scheduler) .observeOn(scheduler) .subscribe(status -> result[0] = status); scheduler.triggerActions(); viewModel.searchForCity.onNext(true); scheduler.triggerActions(); viewModel.onSearchForCityResult(Chain.optional(mockCity())); scheduler.triggerActions(); assertFalse(result[0]); } @Test public void onSearchForCityResultWithInvalidResultThenHideProgress() { boolean[] result = {false}; viewModel.searchCityInProgress .subscribeOn(scheduler) .observeOn(scheduler) .subscribe(status -> result[0] = status); scheduler.triggerActions(); viewModel.searchForCity.onNext(true); scheduler.triggerActions(); viewModel.onSearchForCityResult(Chain.optional(null)); scheduler.triggerActions(); assertFalse(result[0]); }
### Question: IcyHttpDataSourceFactory extends OkHttpDataSource.BaseFactory { @Override protected IcyHttpDataSource createDataSourceInternal(@NonNull HttpDataSource.RequestProperties defaultRequestProperties) { return new IcyHttpDataSource.Builder(callFactory) .setUserAgent(userAgent) .setContentTypePredicate(contentTypePredicate) .setCacheControl(cacheControl) .setDefaultRequestProperties(defaultRequestProperties) .setIcyHeadersListener(icyHeadersListener) .setIcyMetadataListener(icyMetadataListener) .build(); } private IcyHttpDataSourceFactory(); }### Answer: @Test public void createDataSourceViaFactoryFromFactoryBuilder() { OkHttpClient client = new OkHttpClient.Builder().build(); IcyHttpDataSourceFactory factory = new IcyHttpDataSourceFactory.Builder(client) .setUserAgent(Constants.TEST_USER_AGENT) .setIcyHeadersListener(TEST_ICY_HEADERS_LISTENER) .setIcyMetadataChangeListener(TEST_ICY_METADATA_LISTENER) .build(); HttpDataSource.RequestProperties requestProperties = new HttpDataSource.RequestProperties(); IcyHttpDataSource source = factory.createDataSourceInternal(requestProperties); assertNotNull(source); }
### Question: DiskBasedCache implements Cache { @Override public synchronized Entry get(String key) { CacheHeader entry = mEntries.get(key); if (entry == null) { return null; } File file = getFileForKey(key); try { CountingInputStream cis = new CountingInputStream( new BufferedInputStream(createInputStream(file)), file.length()); try { CacheHeader entryOnDisk = CacheHeader.readHeader(cis); if (!TextUtils.equals(key, entryOnDisk.key)) { VolleyLog.d("%s: key=%s, found=%s", file.getAbsolutePath(), key, entryOnDisk.key); removeEntry(key); return null; } byte[] data = streamToBytes(cis, cis.bytesRemaining()); return entry.toCacheEntry(data); } finally { cis.close(); } } catch (IOException e) { VolleyLog.d("%s: %s", file.getAbsolutePath(), e.toString()); remove(key); return null; } } DiskBasedCache(File rootDirectory, int maxCacheSizeInBytes); DiskBasedCache(File rootDirectory); @Override synchronized void clear(); @Override synchronized Entry get(String key); @Override synchronized void initialize(); @Override synchronized void invalidate(String key, boolean fullExpire); @Override synchronized void put(String key, Entry entry); @Override synchronized void remove(String key); File getFileForKey(String key); }### Answer: @Test public void testEmptyInitialize() { assertThat(cache.get("key"), is(nullValue())); }
### Question: DiskBasedCache implements Cache { @Override public synchronized void invalidate(String key, boolean fullExpire) { Entry entry = get(key); if (entry != null) { entry.softTtl = 0; if (fullExpire) { entry.ttl = 0; } put(key, entry); } } DiskBasedCache(File rootDirectory, int maxCacheSizeInBytes); DiskBasedCache(File rootDirectory); @Override synchronized void clear(); @Override synchronized Entry get(String key); @Override synchronized void initialize(); @Override synchronized void invalidate(String key, boolean fullExpire); @Override synchronized void put(String key, Entry entry); @Override synchronized void remove(String key); File getFileForKey(String key); }### Answer: @Test public void testInvalidate() { Cache.Entry entry = randomData(32); entry.softTtl = 8765432L; entry.ttl = 9876543L; cache.put("key", entry); cache.invalidate("key", false); entry.softTtl = 0; assertThatEntriesAreEqual(cache.get("key"), entry); }
### Question: DiskBasedCache implements Cache { static byte[] streamToBytes(CountingInputStream cis, long length) throws IOException { long maxLength = cis.bytesRemaining(); if (length < 0 || length > maxLength || (int) length != length) { throw new IOException("streamToBytes length=" + length + ", maxLength=" + maxLength); } byte[] bytes = new byte[(int) length]; new DataInputStream(cis).readFully(bytes); return bytes; } DiskBasedCache(File rootDirectory, int maxCacheSizeInBytes); DiskBasedCache(File rootDirectory); @Override synchronized void clear(); @Override synchronized Entry get(String key); @Override synchronized void initialize(); @Override synchronized void invalidate(String key, boolean fullExpire); @Override synchronized void put(String key, Entry entry); @Override synchronized void remove(String key); File getFileForKey(String key); }### Answer: @Test public void testStreamToBytesNegativeLength() throws IOException { byte[] data = new byte[1]; CountingInputStream cis = new CountingInputStream(new ByteArrayInputStream(data), data.length); exception.expect(IOException.class); DiskBasedCache.streamToBytes(cis, -1); } @Test public void testStreamToBytesExcessiveLength() throws IOException { byte[] data = new byte[1]; CountingInputStream cis = new CountingInputStream(new ByteArrayInputStream(data), data.length); exception.expect(IOException.class); DiskBasedCache.streamToBytes(cis, 2); } @Test public void testStreamToBytesOverflow() throws IOException { byte[] data = new byte[0]; CountingInputStream cis = new CountingInputStream(new ByteArrayInputStream(data), 0x100000000L); exception.expect(IOException.class); DiskBasedCache.streamToBytes(cis, 0x100000000L); }
### Question: DiskBasedCache implements Cache { @Override public synchronized void put(String key, Entry entry) { pruneIfNeeded(entry.data.length); File file = getFileForKey(key); try { BufferedOutputStream fos = new BufferedOutputStream(createOutputStream(file)); CacheHeader e = new CacheHeader(key, entry); boolean success = e.writeHeader(fos); if (!success) { fos.close(); VolleyLog.d("Failed to write header for %s", file.getAbsolutePath()); throw new IOException(); } fos.write(entry.data); fos.close(); putEntry(key, e); return; } catch (IOException e) { } boolean deleted = file.delete(); if (!deleted) { VolleyLog.d("Could not clean up file %s", file.getAbsolutePath()); } } DiskBasedCache(File rootDirectory, int maxCacheSizeInBytes); DiskBasedCache(File rootDirectory); @Override synchronized void clear(); @Override synchronized Entry get(String key); @Override synchronized void initialize(); @Override synchronized void invalidate(String key, boolean fullExpire); @Override synchronized void put(String key, Entry entry); @Override synchronized void remove(String key); File getFileForKey(String key); }### Answer: @Test public void testManyResponseHeaders() { Cache.Entry entry = new Cache.Entry(); entry.data = new byte[0]; entry.responseHeaders = new HashMap<>(); for (int i = 0; i < 0xFFFF; i++) { entry.responseHeaders.put(Integer.toString(i), ""); } cache.put("key", entry); }
### Question: DiskBasedCache implements Cache { static int readInt(InputStream is) throws IOException { int n = 0; n |= (read(is) << 0); n |= (read(is) << 8); n |= (read(is) << 16); n |= (read(is) << 24); return n; } DiskBasedCache(File rootDirectory, int maxCacheSizeInBytes); DiskBasedCache(File rootDirectory); @Override synchronized void clear(); @Override synchronized Entry get(String key); @Override synchronized void initialize(); @Override synchronized void invalidate(String key, boolean fullExpire); @Override synchronized void put(String key, Entry entry); @Override synchronized void remove(String key); File getFileForKey(String key); }### Answer: @Test public void testEmptyReadThrowsEOF() throws IOException { ByteArrayInputStream empty = new ByteArrayInputStream(new byte[]{}); exception.expect(EOFException.class); DiskBasedCache.readInt(empty); }
### Question: ImageRequest extends Request<Bitmap> { static int findBestSampleSize( int actualWidth, int actualHeight, int desiredWidth, int desiredHeight) { double wr = (double) actualWidth / desiredWidth; double hr = (double) actualHeight / desiredHeight; double ratio = Math.min(wr, hr); float n = 1.0f; while ((n * 2) <= ratio) { n *= 2; } return (int) n; } ImageRequest(String url, Response.Listener<Bitmap> listener, int maxWidth, int maxHeight, ScaleType scaleType, Config decodeConfig, Response.ErrorListener errorListener); @Deprecated ImageRequest(String url, Response.Listener<Bitmap> listener, int maxWidth, int maxHeight, Config decodeConfig, Response.ErrorListener errorListener); @Override Priority getPriority(); @Override void cancel(); static final int DEFAULT_IMAGE_TIMEOUT_MS; static final int DEFAULT_IMAGE_MAX_RETRIES; static final float DEFAULT_IMAGE_BACKOFF_MULT; }### Answer: @Test public void findBestSampleSize() { assertEquals(1, ImageRequest.findBestSampleSize(100, 150, 100, 150)); assertEquals(2, ImageRequest.findBestSampleSize(280, 160, 140, 80)); assertEquals(1, ImageRequest.findBestSampleSize(1000, 800, 501, 401)); assertEquals(4, ImageRequest.findBestSampleSize(100, 200, 24, 50)); }
### Question: HurlStack extends BaseHttpStack { static List<Header> convertHeaders(Map<String, List<String>> responseHeaders) { List<Header> headerList = new ArrayList<>(responseHeaders.size()); for (Map.Entry<String, List<String>> entry : responseHeaders.entrySet()) { if (entry.getKey() != null) { for (String value : entry.getValue()) { headerList.add(new Header(entry.getKey(), value)); } } } return headerList; } HurlStack(); HurlStack(UrlRewriter urlRewriter); HurlStack(UrlRewriter urlRewriter, SSLSocketFactory sslSocketFactory); @Override HttpResponse executeRequest(Request<?> request, Map<String, String> additionalHeaders); }### Answer: @Test public void convertHeaders() { Map<String, List<String>> headers = new HashMap<>(); headers.put(null, Collections.singletonList("Ignored")); headers.put("HeaderA", Collections.singletonList("ValueA")); List<String> values = new ArrayList<>(); values.add("ValueB_1"); values.add("ValueB_2"); headers.put("HeaderB", values); List<Header> result = HurlStack.convertHeaders(headers); List<Header> expected = new ArrayList<>(); expected.add(new Header("HeaderA", "ValueA")); expected.add(new Header("HeaderB", "ValueB_1")); expected.add(new Header("HeaderB", "ValueB_2")); assertEquals(expected, result); }
### Question: Instance { public Attribute getAttr(String fieldName) { return attributes.get(fieldName); } Instance(); double getWeight(); void setWeight(double w); void setAttr(String name, Object value); Attribute getAttr(String fieldName); Object getAttrValue(String fieldName); int hashCode(); String toString(); }### Answer: @Test public void testInstanceCreationAndReadAccessor() { Schema schema = Schema.createSchemaStructure(Car.class, Learner.DataType.STRUCTURED); InstanceFactory instFactory = new InstanceFactory(schema); Instance m1 = instFactory.createInstance(new Car( "m1",2, "s", "p", "low")); Instance m2 = instFactory.createInstance(new Car( "m2",2, "s", "d", "medium")); Instance m3 = instFactory.createInstance(new Car( "m3",2, "s", "e", "high")); assertEquals( "m1", m1.getAttr("org.drools.learner.Car@model").getValue() ); assertEquals( "s", m2.getAttr("org.drools.learner.Car@size").getValue() ); assertEquals( "e", m3.getAttr("org.drools.learner.Car@fuel").getValue() ); }
### Question: Spec { public String getOutput() { return output; } Spec(); String getName(); Spec setName(String name); Map<String, DeclaredType> getTypes(); Map<String, Input> getInputs(); List<Rule> getRules(); Spec setRules(List<Rule> rules); String getOutput(); void setOutput(String output); void validateType(String type); boolean isValidType(String type); boolean mustParse(String input, String field); static final String FIELD_NAME; static final String FIELD_TYPES; static final String FIELD_INPUTS; static final String FIELD_RULES; static final String FIELD_OUTPUT; }### Answer: @Test public void testOutputComplexType() throws IOException { JsonObject json = Json.createObjectBuilder() .add(Spec.FIELD_INPUTS, Json.createArrayBuilder()) .add(Spec.FIELD_TYPES, buildTypes()) .add(Spec.FIELD_RULES, Json.createArrayBuilder()) .add(Spec.FIELD_OUTPUT, "Person") .build(); Spec spec = parseSpec(json); assertEquals("Person", spec.getOutput()); }
### Question: Spec { public Map<String, DeclaredType> getTypes() { return types; } Spec(); String getName(); Spec setName(String name); Map<String, DeclaredType> getTypes(); Map<String, Input> getInputs(); List<Rule> getRules(); Spec setRules(List<Rule> rules); String getOutput(); void setOutput(String output); void validateType(String type); boolean isValidType(String type); boolean mustParse(String input, String field); static final String FIELD_NAME; static final String FIELD_TYPES; static final String FIELD_INPUTS; static final String FIELD_RULES; static final String FIELD_OUTPUT; }### Answer: @Test public void testParseDeclare() throws IOException { JsonObject json = Json.createObjectBuilder() .add(Spec.FIELD_INPUTS, Json.createArrayBuilder()) .add(Spec.FIELD_TYPES, buildTypes()) .add(Spec.FIELD_OUTPUT, FieldType.STRING.getValue()) .build(); Spec spec = parseSpec(json); assertNotNull(spec); assertFalse(spec.getTypes().isEmpty()); assertEquals(FieldType.STRING, spec.getTypes().get("Person").getDefinition().get("name")); assertEquals(FieldType.INTEGER, spec.getTypes().get("Person").getDefinition().get("age")); }
### Question: ConverterUtils { public String parseOutput(String right) { return parseOutput(null, right); } ConverterUtils(Spec spec); String parseOutput(String right); String parseOutput(String left, String right); String getGetter(String text); }### Answer: @Test public void testGetOutputFieldTypeString() { Spec spec = buildSpec(); spec.setOutput("string"); ConverterUtils converter = new ConverterUtils(spec); assertEquals("output.setString(\"F\");", converter.parseOutput("F")); assertEquals("output.setString(String.format(\"Full name: %s %s\", user.getFirstName(), user.getLastName()));", converter.parseOutput("Full name: $user.firstName $user.lastName")); } @Test public void testGetOutputFieldTypeInteger() { Spec spec = buildSpec(); spec.setOutput("integer"); ConverterUtils converter = new ConverterUtils(spec); assertEquals("output.setInteger(34);", converter.parseOutput("34")); assertEquals("output.setInteger(user.getAge() * 2);", converter.parseOutput("$user.age * 2")); } @Test public void testGetOutputFieldTypeNumber() { Spec spec = buildSpec(); spec.setOutput("number"); ConverterUtils converter = new ConverterUtils(spec); assertEquals("output.setNumber((math.getNumber() + physics.getNumber() + biology.getNumber()) / 3);", converter.parseOutput("($math + $physics + $biology) / 3")); } @Test public void testGetOutputDeclaredType() { Spec spec = buildSpec(); spec.setOutput("Results"); ConverterUtils converter = new ConverterUtils(spec); assertEquals("output.setAverage((math.getNumber() + physics.getNumber() + biology.getNumber()) / 3);", converter.parseOutput("average", "($math + $physics + $biology) / 3")); assertEquals("output.setMax(math.getNumber());", converter.parseOutput("max", "$math")); assertEquals("output.setSubject(\"Math\");", converter.parseOutput("subject", "Math")); }
### Question: ConverterUtils { public String getGetter(String text) { String[] parts = text.split(VARIABLE_SEPARATOR); if (parts.length == 0) { return ""; } if (parts.length == 1) { return getGetter(text + "." + types.get(text).getValue()); } StringBuffer getter = new StringBuffer(parts[0]); for (int i = 1; i < parts.length; i++) { getter.append(".get").append(parts[i].substring(0, 1).toUpperCase()).append(parts[i].substring(1)).append("()"); } return getter.toString(); } ConverterUtils(Spec spec); String parseOutput(String right); String parseOutput(String left, String right); String getGetter(String text); }### Answer: @Test public void testGetter() { ConverterUtils converter = new ConverterUtils(buildSpec()); assertEquals("name.getString()", converter.getGetter("name")); assertEquals("user.getAge()", converter.getGetter("user.age")); assertEquals("grade.getNumber()", converter.getGetter("grade")); }
### Question: Value { public boolean cmp(Value o) { if (o == null) { return false; } if (rlp != null && o.rlp != null) { return Arrays.equals(rlp, o.rlp); } else { return Arrays.equals(this.encode(), o.encode()); } } private Value(); Value(Object obj); static Value fromRlpEncoded(byte[] data); Object asObj(); List<Object> asList(); int asInt(); long asLong(); BigInteger asBigInt(); String asString(); byte[] asBytes(); byte[] getData(); Value get(int index); byte[] encode(); boolean cmp(Value o); boolean isList(); boolean isString(); boolean isBytes(); boolean isHashCode(); boolean isNull(); int length(); String toString(); }### Answer: @Test public void testCmp() { Value val1 = new Value("hello"); Value val2 = new Value("world"); assertFalse("Expected values not to be equal", val1.cmp(val2)); Value val3 = new Value("hello"); Value val4 = new Value("hello"); assertTrue("Expected values to be equal", val3.cmp(val4)); Value inter = new Value(new Object[] {1}); Object[] interExp = new Object[] {1}; assertTrue(new Value(inter.asObj()).cmp(new Value(interExp))); String dog = "dog"; Value val5 = new Value(dog); Value val6 = Value.fromRlpEncoded(Hex.decode("83646f67")); assertThat(val5.cmp(val6)).isTrue(); val5 = Value.fromRlpEncoded(Hex.decode("83646f67")); assertThat(val5.cmp(val6)).isTrue(); val5 = Value.fromRlpEncoded(Hex.decode("83636174")); assertThat(val5.cmp(val6)).isFalse(); assertThat(val6.cmp(null)).isFalse(); }
### Question: RLP { public static byte[] encodeLength(int length, int offset) { if (length < SIZE_THRESHOLD) { byte firstByte = (byte) (length + offset); return new byte[] {firstByte}; } else { byte[] binaryLength; if (length > 0xFF) { binaryLength = intToBytesNoLeadZeroes(length); } else { binaryLength = new byte[] {(byte) length}; } byte firstByte = (byte) (binaryLength.length + offset + SIZE_THRESHOLD - 1); return concatenate(new byte[] {firstByte}, binaryLength); } } static int decodeInt(byte[] data, int index); static BigInteger decodeBigInteger(byte[] data, int index); static RLPList decode2(byte[] msgData); static RLPElement decode2OneItem(byte[] msgData, int startPos); static DecodeResult decode(byte[] data, int pos); static byte[] encode(Object input); static byte[] encodeLength(int length, int offset); static byte[] encodeByte(byte singleByte); static byte[] encodeShort(short singleShort); static byte[] encodeInt(int singleInt); static byte[] encodeLong(long l); static byte[] encodeString(String srcString); static byte[] encodeBigInteger(BigInteger srcBigInteger); static byte[] encodeElement(byte[] srcData); static int calcElementPrefixSize(byte[] srcData); static byte[] encodeListHeader(int size); static byte[] encodeLongElementHeader(int length); static byte[] encodeList(byte[]... elements); }### Answer: @Test public void testEncodeLength() { int length = 1; int offset = 128; byte[] encodedLength = encodeLength(length, offset); String expected = "81"; assertEquals(expected, Hex.toHexString(encodedLength)); length = 56; offset = 192; encodedLength = encodeLength(length, offset); expected = "f838"; assertEquals(expected, Hex.toHexString(encodedLength)); }
### Question: DecodeResult implements Serializable { @Override public String toString() { return asString(this.decoded); } DecodeResult(int pos, Object decoded); int getPos(); Object getDecoded(); @Override String toString(); }### Answer: @Test(expected = RuntimeException.class) public void testAsString_wRuntimeException() { DecodeResult res = new DecodeResult(0, null); res.toString(); }
### Question: RLP { public static byte[] encodeLong(long l) { if ((l & 0x00000000FFFFFFFFL) == l) { return encodeInt((int) l); } else { byte[] out = new byte[9]; out[0] = (byte) (OFFSET_SHORT_ITEM + 8); for (int i = 8; i > 0; i--) { out[i] = (byte) l; l >>>= 8; } return out; } } static int decodeInt(byte[] data, int index); static BigInteger decodeBigInteger(byte[] data, int index); static RLPList decode2(byte[] msgData); static RLPElement decode2OneItem(byte[] msgData, int startPos); static DecodeResult decode(byte[] data, int pos); static byte[] encode(Object input); static byte[] encodeLength(int length, int offset); static byte[] encodeByte(byte singleByte); static byte[] encodeShort(short singleShort); static byte[] encodeInt(int singleInt); static byte[] encodeLong(long l); static byte[] encodeString(String srcString); static byte[] encodeBigInteger(BigInteger srcBigInteger); static byte[] encodeElement(byte[] srcData); static int calcElementPrefixSize(byte[] srcData); static byte[] encodeListHeader(int size); static byte[] encodeLongElementHeader(int length); static byte[] encodeList(byte[]... elements); }### Answer: @Test public void testEncodeDecodeDownToByte() { Long num = 1L; byte[] res = RLP.encodeLong(num); assertEquals(res.length, 1); }
### Question: CompactEncoder { public static byte[] packNibbles(byte[] nibbles) { int terminator = 0; int len = nibbles.length; if (len > 0 && nibbles[len - 1] == TERMINATOR) { terminator = 1; --len; } int oddlen = len & 1; int flag = (terminator << 1) + oddlen; byte[] output = new byte[(len >>> 1) + 1]; if (oddlen != 0) { output[0] = (byte) ((flag << 4) + nibbles[0]); } else { output[0] = (byte) (flag << 4); } for (int i = oddlen, index = 1; i < len; i += 2, index++) { output[index] = (byte) ((nibbles[i] << 4) + nibbles[i + 1]); } return output; } static byte[] packNibbles(byte[] nibbles); static boolean hasTerminator(byte[] packedKey); static byte[] unpackToNibbles(byte[] str); static byte[] binToNibbles(byte[] str); }### Answer: @Test(expected = NullPointerException.class) public void testCompactEncode_wNullArray() { CompactEncoder.packNibbles(null); }
### Question: CompactEncoder { public static boolean hasTerminator(byte[] packedKey) { return ((packedKey[0] >> 4) & 2) != 0; } static byte[] packNibbles(byte[] nibbles); static boolean hasTerminator(byte[] packedKey); static byte[] unpackToNibbles(byte[] str); static byte[] binToNibbles(byte[] str); }### Answer: @Test(expected = NullPointerException.class) public void testHasTerminator_wNullArray() { CompactEncoder.hasTerminator(null); }
### Question: Utils { static byte[] hexEncode(byte[] in) { if (in == null) { return null; } byte[] ret = new byte[in.length << 1]; for (int i = 0; i < in.length; i++) { int v = in[i] & 0xff; ret[i << 1] = hexMap.get((char) encodingTable[v >>> 4]); ret[(i << 1) + 1] = hexMap.get((char) encodingTable[v & 0xf]); } return ret; } }### Answer: @Test public void testHexEncode_wNull() { assertThat(Utils.hexEncode(null)).isNull(); } @Test public void testHexEncode_wSingleByte() { for (byte b : encodingTable) { byte[] input = new byte[] {b}; byte[] rlpHexEncodeOutput = Utils.hexEncode(input); byte[] hexEncodeOutput = Hex.encode(input); assertEquals(rlpHexEncodeOutput.length, hexEncodeOutput.length); for (int i = 0; i < rlpHexEncodeOutput.length; i++) { assertThat(rlpHexEncodeOutput[i]) .isEqualTo(hexMap.get((char) encodingTable[hexEncodeOutput[i] & 0xf])); } } } @Test public void testHexEncode_woTerminatorByte() { String value = "1234567890abcdef"; byte[] input = Hex.decode(value); byte[] rlpHexEncodeOutput = Utils.hexEncode(input); byte[] expectOutput = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15}; assertArrayEquals(rlpHexEncodeOutput, expectOutput); }
### Question: RLP { public static byte[] encodeByte(byte singleByte) { if ((singleByte & 0xFF) == 0) { return BYTES_SHORT_ITEM; } else if ((singleByte & 0xFF) <= 0x7F) { return new byte[] {singleByte}; } else { return new byte[] {(byte) (OFFSET_SHORT_ITEM + 1), singleByte}; } } static int decodeInt(byte[] data, int index); static BigInteger decodeBigInteger(byte[] data, int index); static RLPList decode2(byte[] msgData); static RLPElement decode2OneItem(byte[] msgData, int startPos); static DecodeResult decode(byte[] data, int pos); static byte[] encode(Object input); static byte[] encodeLength(int length, int offset); static byte[] encodeByte(byte singleByte); static byte[] encodeShort(short singleShort); static byte[] encodeInt(int singleInt); static byte[] encodeLong(long l); static byte[] encodeString(String srcString); static byte[] encodeBigInteger(BigInteger srcBigInteger); static byte[] encodeElement(byte[] srcData); static int calcElementPrefixSize(byte[] srcData); static byte[] encodeListHeader(int size); static byte[] encodeLongElementHeader(int length); static byte[] encodeList(byte[]... elements); }### Answer: @Test public void testEncodeByte() { byte[] expected = {(byte) 0x80}; byte[] data = encodeByte((byte) 0); assertArrayEquals(expected, data); byte[] expected2 = {(byte) 0x78}; data = encodeByte((byte) 120); assertArrayEquals(expected2, data); byte[] expected3 = {(byte) 0x7F}; data = encodeByte((byte) 127); assertArrayEquals(expected3, data); }
### Question: Utils { static byte[] hexEncodeWithTerminatorByte(byte[] in) { if (in == null) { return null; } byte[] ret = new byte[(in.length << 1) + 1]; for (int i = 0; i < in.length; i++) { int v = in[i] & 0xff; ret[i << 1] = hexMap.get((char) encodingTable[v >>> 4]); ret[(i << 1) + 1] = hexMap.get((char) encodingTable[v & 0xf]); } ret[ret.length - 1] = TERMINATOR; return ret; } }### Answer: @Test public void testHexEncode_wTerminatorByte() { String value = "1234567890abcdef"; byte[] input = Hex.decode(value); byte[] expectOutput = new byte[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 10, 11, 12, 13, 14, 15, 16}; byte[] rlpHexEncodeOutput = Utils.hexEncodeWithTerminatorByte(input); assertArrayEquals(rlpHexEncodeOutput, expectOutput); }
### Question: Utils { static byte[] concatenate(byte[] a, byte[] b) { byte[] ret = new byte[a.length + b.length]; System.arraycopy(a, 0, ret, 0, a.length); System.arraycopy(b, 0, ret, a.length, b.length); return ret; } }### Answer: @Test(expected = NullPointerException.class) public void testConcatenate_wNullA() { Utils.concatenate(new byte[] {1, 2}, null); } @Test(expected = NullPointerException.class) public void testConcatenate_wNullB() { Utils.concatenate(null, new byte[] {1, 2}); } @Test public void testConcatenate() { assertThat(Utils.concatenate(new byte[] {1, 2}, new byte[] {3, 4})) .isEqualTo(new byte[] {1, 2, 3, 4}); } @Test public void testConcatenate_wEmptyFirstArray() { assertThat(Utils.concatenate(new byte[] {}, new byte[] {3, 4})) .isEqualTo(new byte[] {3, 4}); } @Test public void testConcatenate_wEmptySecondArray() { assertThat(Utils.concatenate(new byte[] {1, 2}, new byte[] {})) .isEqualTo(new byte[] {1, 2}); } @Test public void testConcatenate_wEmptyArrays() { assertThat(Utils.concatenate(new byte[] {}, new byte[] {})).isEqualTo(new byte[] {}); }
### Question: LogApproximator { public static FixedPoint log(BigInteger input) { if (null == input || input.compareTo(BigInteger.ONE) < 0) { throw new IllegalArgumentException("Invalid input to log approximator"); } else if (input.compareTo(BigInteger.ONE) == 0) { return FixedPoint.ZERO; } else { int bitLength = input.bitLength(); FixedPoint x = new FixedPoint(input.shiftLeft(FixedPoint.PRECISION - bitLength)); FixedPoint y = log2.multiplyInteger(bitLength); int leftShift = 1; while (leftShift < logTable.size() && x.compareTo(FixedPoint.ONE) <= 0) { FixedPoint xPrime = x.add(x.divideByPowerOfTwo(leftShift)); if (xPrime.compareTo(FixedPoint.ONE) <= 0) { x = xPrime; y = y.subtract(logTable.get(leftShift)); } else { leftShift++; } } y = y.add(x).subtract(FixedPoint.ONE); return y; } } static FixedPoint log(BigInteger input); }### Answer: @Test public void testLog123456789() { Assert.assertEquals(Math.log(123456789), LogApproximator.log(new BigInteger("123456789")).toBigDecimal().doubleValue(), delta); } @Ignore @Test public void testCollisions() { Set<FixedPoint> logs = new HashSet(); for (int i = 2; i < (1 << 20); i++) { FixedPoint log = LogApproximator.log(BigInteger.valueOf(i)); if (logs.contains(log)) { System.out.println("log of " + i + " is " + log + " which is already there"); } else { logs.add(log); } } }
### Question: FixedPoint { public int compareTo(FixedPoint comparand) { if (null == comparand) { throw new IllegalArgumentException("Null input to FixedPoint method"); } return value.compareTo(comparand.value); } FixedPoint(BigInteger value); static FixedPoint fromString(String inputString); FixedPoint add(FixedPoint addend); FixedPoint subtract(FixedPoint subtrahend); FixedPoint multiplyInteger(BigInteger multiplicand); FixedPoint multiplyInteger(int multiplicand); FixedPoint divideByPowerOfTwo(int shift); int compareTo(FixedPoint comparand); BigInteger toBigInteger(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final int PRECISION; static final BigInteger MAX_PRECISION; static final FixedPoint ZERO; static final FixedPoint ONE; }### Answer: @Test public void testComparator() { Assert.assertEquals(f1.compareTo(f2), -1); Assert.assertEquals(f2.compareTo(f1), 1); Assert.assertEquals(f1.compareTo(f1), 0); }
### Question: FixedPoint { @Override public String toString() { return toBigDecimal().toPlainString(); } FixedPoint(BigInteger value); static FixedPoint fromString(String inputString); FixedPoint add(FixedPoint addend); FixedPoint subtract(FixedPoint subtrahend); FixedPoint multiplyInteger(BigInteger multiplicand); FixedPoint multiplyInteger(int multiplicand); FixedPoint divideByPowerOfTwo(int shift); int compareTo(FixedPoint comparand); BigInteger toBigInteger(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final int PRECISION; static final BigInteger MAX_PRECISION; static final FixedPoint ZERO; static final FixedPoint ONE; }### Answer: @Test public void testToString() { FixedPoint fixedPoint = FixedPoint.fromString("5.4375"); Assert.assertEquals("5.4375", fixedPoint.toString()); }
### Question: FixedPoint { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; FixedPoint that = (FixedPoint) o; return value.equals(that.value); } FixedPoint(BigInteger value); static FixedPoint fromString(String inputString); FixedPoint add(FixedPoint addend); FixedPoint subtract(FixedPoint subtrahend); FixedPoint multiplyInteger(BigInteger multiplicand); FixedPoint multiplyInteger(int multiplicand); FixedPoint divideByPowerOfTwo(int shift); int compareTo(FixedPoint comparand); BigInteger toBigInteger(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); static final int PRECISION; static final BigInteger MAX_PRECISION; static final FixedPoint ZERO; static final FixedPoint ONE; }### Answer: @Test public void testEquals() { FixedPoint f1Copy = FixedPoint.fromString("1.6875"); Assert.assertNotEquals(f1, f2); Assert.assertEquals(f1, f1Copy); Assert.assertEquals(f1, f1); }
### Question: Random { public byte[] randomBytes(int n) { byte[] buffer = new byte[n]; sodium().randombytes(buffer, n); return buffer; } byte[] randomBytes(int n); byte[] randomBytes(); }### Answer: @Test public void testProducesRandomBytes() throws Exception { final int size = 16; assertEquals("Invalid random bytes", size, new Random().randomBytes(size).length); } @Test public void testProducesDefaultRandomBytes() throws Exception { final int size = 32; assertEquals("Invalid random bytes", size, new Random().randomBytes().length); } @Test public void testProducesDifferentRandomBytes() throws Exception { final int size = 16; assertFalse("Should produce different random bytes", Arrays.equals(new Random().randomBytes(size), new Random().randomBytes(size))); } @Test public void testProducesDifferentDefaultRandomBytes() throws Exception { final int size = 32; assertFalse("Should produce different random bytes", Arrays.equals(new Random().randomBytes(), new Random().randomBytes(size))); }
### Question: Util { public static byte[] prependZeros(int n, byte[] message) { byte[] result = new byte[n + message.length]; Arrays.fill(result, (byte) 0); System.arraycopy(message, 0, result, n, message.length); return result; } static byte[] prependZeros(int n, byte[] message); static byte[] removeZeros(int n, byte[] message); static void checkLength(byte[] data, int size); static byte[] zeros(int n); static boolean isValid(int status, String message); static byte[] slice(byte[] buffer, int start, int end); static byte[] merge(byte[] signature, byte[] message); }### Answer: @Test public void testPrependZeros() throws Exception { byte[] src = {'t', 'e', 's', 't'}; byte[] result = Util.prependZeros(3, src); Assert.assertArrayEquals(new byte[]{0, 0, 0, 't', 'e', 's', 't'}, result); }
### Question: SecretBox { public byte[] encrypt(byte[] nonce, byte[] message) { checkLength(nonce, XSALSA20_POLY1305_SECRETBOX_NONCEBYTES); byte[] msg = Util.prependZeros(ZERO_BYTES, message); byte[] ct = Util.zeros(msg.length); isValid(sodium().crypto_secretbox_xsalsa20poly1305(ct, msg, msg.length, nonce, key), "Encryption failed"); return removeZeros(BOXZERO_BYTES, ct); } SecretBox(byte[] key); SecretBox(String key, Encoder encoder); byte[] encrypt(byte[] nonce, byte[] message); byte[] decrypt(byte[] nonce, byte[] ciphertext); }### Answer: @Test public void testEncrypt() throws Exception { SecretBox box = new SecretBox(SECRET_KEY, HEX); byte[] nonce = HEX.decode(BOX_NONCE); byte[] message = HEX.decode(BOX_MESSAGE); byte[] ciphertext = HEX.decode(BOX_CIPHERTEXT); byte[] result = box.encrypt(nonce, message); assertTrue("failed to generate ciphertext", Arrays.equals(result, ciphertext)); }
### Question: SecretBox { public byte[] decrypt(byte[] nonce, byte[] ciphertext) { checkLength(nonce, XSALSA20_POLY1305_SECRETBOX_NONCEBYTES); byte[] ct = Util.prependZeros(BOXZERO_BYTES, ciphertext); byte[] message = Util.zeros(ct.length); isValid(sodium().crypto_secretbox_xsalsa20poly1305_open(message, ct, ct.length, nonce, key), "Decryption failed. Ciphertext failed verification"); return removeZeros(ZERO_BYTES, message); } SecretBox(byte[] key); SecretBox(String key, Encoder encoder); byte[] encrypt(byte[] nonce, byte[] message); byte[] decrypt(byte[] nonce, byte[] ciphertext); }### Answer: @Test public void testDecrypt() throws Exception { SecretBox box = new SecretBox(SECRET_KEY, HEX); byte[] nonce = HEX.decode(BOX_NONCE); byte[] expectedMessage = HEX.decode(BOX_MESSAGE); byte[] ciphertext = box.encrypt(nonce, expectedMessage); byte[] message = box.decrypt(nonce, ciphertext); assertTrue("failed to decrypt ciphertext", Arrays.equals(message, expectedMessage)); }
### Question: Hash { public byte[] sha256(byte[] message) { buffer = new byte[SodiumConstants.SHA256BYTES]; sodium().crypto_hash_sha256(buffer, message, message.length); return buffer; } byte[] sha256(byte[] message); byte[] sha512(byte[] message); String sha256(String message, Encoder encoder); String sha512(String message, Encoder encoder); String pwhash_scryptsalsa208sha256(String passwd, Encoder encoder, byte[] salt, int opslimit, int memlimit); byte[] blake2(byte[] message); String blake2(String message, Encoder encoder); }### Answer: @Test public void testSha256() throws Exception { final byte[] rawMessage = TestVectors.SHA256_MESSAGE.getBytes(); String result = HEX.encode(hash.sha256(rawMessage)); assertTrue("Hash is invalid", Arrays.equals(TestVectors.SHA256_DIGEST.getBytes(), result.getBytes())); } @Test public void testSha256EmptyString() throws Exception { byte[] result = hash.sha256("".getBytes()); assertEquals("Hash is invalid", TestVectors.SHA256_DIGEST_EMPTY_STRING, HEX.encode(result)); } @Test public void testSha256HexString() throws Exception { String result = hash.sha256(TestVectors.SHA256_MESSAGE, HEX); Assert.assertEquals("Hash is invalid", TestVectors.SHA256_DIGEST, result); } @Test public void testSha256EmptyHexString() throws Exception { String result = hash.sha256("", HEX); Assert.assertEquals("Hash is invalid", TestVectors.SHA256_DIGEST_EMPTY_STRING, result); } @Test public void testSha256NullByte() { try { hash.sha256("\0".getBytes()); } catch (Exception e) { fail("Should not raise any exception on null byte"); } }
### Question: Hash { public byte[] sha512(byte[] message) { buffer = new byte[SodiumConstants.SHA512BYTES]; sodium().crypto_hash_sha512(buffer, message, message.length); return buffer; } byte[] sha256(byte[] message); byte[] sha512(byte[] message); String sha256(String message, Encoder encoder); String sha512(String message, Encoder encoder); String pwhash_scryptsalsa208sha256(String passwd, Encoder encoder, byte[] salt, int opslimit, int memlimit); byte[] blake2(byte[] message); String blake2(String message, Encoder encoder); }### Answer: @Test public void testSha512() throws Exception { final byte[] rawMessage = TestVectors.SHA512_MESSAGE.getBytes(); String result = HEX.encode(hash.sha512(rawMessage)); assertTrue("Hash is invalid", Arrays.equals(TestVectors.SHA512_DIGEST.getBytes(), result.getBytes())); } @Test public void testSha512EmptyString() throws Exception { byte[] result = hash.sha512("".getBytes()); assertEquals("Hash is invalid", TestVectors.SHA512_DIGEST_EMPTY_STRING, HEX.encode(result)); } @Test public void testSha512HexString() throws Exception { String result = hash.sha512(TestVectors.SHA512_MESSAGE, HEX); Assert.assertEquals("Hash is invalid", TestVectors.SHA512_DIGEST, result); } @Test public void testSha512EmptyHexString() throws Exception { String result = hash.sha512("", HEX); Assert.assertEquals("Hash is invalid", TestVectors.SHA512_DIGEST_EMPTY_STRING, result); } @Test public void testSha512NullByte() { try { hash.sha512("\0".getBytes()); } catch (Exception e) { fail("Should not raise any exception on null byte"); } }
### Question: Hash { public byte[] blake2(byte[] message) throws UnsupportedOperationException { if (!blakeSupportedVersion()) throw new UnsupportedOperationException(); buffer = new byte[SodiumConstants.BLAKE2B_OUTBYTES]; sodium().crypto_generichash_blake2b(buffer, SodiumConstants.BLAKE2B_OUTBYTES, message, message.length, new byte[0], 0); return buffer; } byte[] sha256(byte[] message); byte[] sha512(byte[] message); String sha256(String message, Encoder encoder); String sha512(String message, Encoder encoder); String pwhash_scryptsalsa208sha256(String passwd, Encoder encoder, byte[] salt, int opslimit, int memlimit); byte[] blake2(byte[] message); String blake2(String message, Encoder encoder); }### Answer: @Test public void testBlake2() throws Exception { final byte[] rawMessage = Blake2_Message.getBytes(); String result = HEX.encode(hash.blake2(rawMessage)); assertEquals(HASH_ERR,Blake2_HEXDIGEST,result); } @Test public void testBlake2EmptyString() throws Exception { byte[] result = hash.blake2("".getBytes()); assertEquals(HASH_ERR, Blake2_DIGEST_EMPTY_STRING, HEX.encode(result)); } @Test public void testBlake2HexString() throws Exception { String result = hash.blake2(Blake2_Message, HEX); assertEquals(HASH_ERR,Blake2_HEXDIGEST,result); } @Test public void testBlake2EmptyHexString() throws Exception { String result = hash.blake2("", HEX); assertEquals(HASH_ERR, Blake2_DIGEST_EMPTY_STRING, result); } @Test public void testBlake2NullByte() { byte[] result=hash.blake2("\0".getBytes()); assertEquals(HASH_ERR, Blake2_DIGEST_NULL, HEX.encode(result)); }
### Question: Point { public byte[] toBytes() { return point; } Point(); Point(byte[] point); Point(String point, Encoder encoder); Point mult(byte[] n); Point mult(String n, Encoder encoder); @Override String toString(); byte[] toBytes(); }### Answer: @Test public void testSerializeToBytes() throws Exception { Point point = new Point(TestVectors.BOB_PUBLIC_KEY, HEX); assertTrue("Should serialize to bytes", Arrays.equals(HEX.decode(TestVectors.BOB_PUBLIC_KEY), point.toBytes())); }
### Question: Point { @Override public String toString() { return HEX.encode(point); } Point(); Point(byte[] point); Point(String point, Encoder encoder); Point mult(byte[] n); Point mult(String n, Encoder encoder); @Override String toString(); byte[] toBytes(); }### Answer: @Test public void testSerializeToHex() throws Exception { Point point = new Point(TestVectors.BOB_PUBLIC_KEY, HEX); Assert.assertEquals("Should serialize to hex", TestVectors.BOB_PUBLIC_KEY, point.toString()); }
### Question: Raw implements Encoder { @Override public String encode(byte[] data) { return data != null ? new String(data, CHARSET) : null; } byte[] decode(final String data); @Override String encode(byte[] data); }### Answer: @Test public void testEncode() throws Exception { String value = "hello"; assertEquals(value, encoder.encode(value.getBytes())); } @Test public void testEncodeNullString() throws Exception { byte[] value = null; try { assertNull(encoder.encode(value)); } catch (Exception e) { fail("Should not raise any exception"); } }
### Question: Raw implements Encoder { public byte[] decode(final String data) { return data != null ? data.getBytes(CHARSET) : null; } byte[] decode(final String data); @Override String encode(byte[] data); }### Answer: @Test public void testDecode() throws Exception { String value = "hello"; assertTrue(Arrays.equals(encoder.decode(value), value.getBytes())); } @Test public void testDecodeNullString() throws Exception { String value = null; try { assertNull(encoder.decode(value)); } catch (Exception e) { e.printStackTrace(); fail("Should not raise any exception"); } }
### Question: SigningKey { @Override public String toString() { return Encoder.HEX.encode(seed); } SigningKey(byte[] seed); SigningKey(); SigningKey(String seed, Encoder encoder); VerifyKey getVerifyKey(); byte[] sign(byte[] message); String sign(String message, Encoder encoder); byte[] toBytes(); @Override String toString(); }### Answer: @Test public void testCreateHexValidKey() throws Exception { try { new SigningKey(SIGN_PRIVATE, HEX).toString(); } catch (Exception e) { e.printStackTrace(); fail("Should return a valid key size"); } } @Test public void testSerializesToHex() throws Exception { try { SigningKey key = new SigningKey(SIGN_PRIVATE, HEX); assertEquals("Correct sign key expected", SIGN_PRIVATE, key.toString()); } catch (Exception e) { fail("Should return a valid key size"); } }
### Question: SigningKey { public byte[] toBytes() { return seed; } SigningKey(byte[] seed); SigningKey(); SigningKey(String seed, Encoder encoder); VerifyKey getVerifyKey(); byte[] sign(byte[] message); String sign(String message, Encoder encoder); byte[] toBytes(); @Override String toString(); }### Answer: @Test public void testCreateByteValidKey() throws Exception { try { new SigningKey(SIGN_PRIVATE, HEX).toBytes(); } catch (Exception e) { e.printStackTrace(); fail("Should return a valid key size"); } } @Test public void testSerializesToBytes() throws Exception { try { byte[] rawKey = HEX.decode(SIGN_PRIVATE); SigningKey key = new SigningKey(SIGN_PRIVATE, HEX); assertTrue("Correct sign key expected", Arrays.equals(rawKey, key.toBytes())); } catch (Exception e) { fail("Should return a valid key size"); } }
### Question: SigningKey { public byte[] sign(byte[] message) { byte[] signature = Util.prependZeros(SIGNATURE_BYTES, message); int[] bufferLen = new int[1]; sodium().crypto_sign_ed25519(signature, bufferLen, message, message.length, secretKey); signature = Util.slice(signature, 0, SIGNATURE_BYTES); return signature; } SigningKey(byte[] seed); SigningKey(); SigningKey(String seed, Encoder encoder); VerifyKey getVerifyKey(); byte[] sign(byte[] message); String sign(String message, Encoder encoder); byte[] toBytes(); @Override String toString(); }### Answer: @Test public void testSignMessageAsBytes() throws Exception { byte[] rawKey = HEX.decode(SIGN_PRIVATE); byte[] signatureRaw = HEX.decode(SIGN_SIGNATURE); SigningKey key = new SigningKey(rawKey); byte[] signedMessage = key.sign(HEX.decode(SIGN_MESSAGE)); assertTrue("Message sign has failed", Arrays.equals(signatureRaw, signedMessage)); } @Test public void testSignMessageAsHex() throws Exception { SigningKey key = new SigningKey(SIGN_PRIVATE, HEX); String signature = key.sign(SIGN_MESSAGE, HEX); assertEquals("Message sign has failed", SIGN_SIGNATURE, signature); }
### Question: VerifyKey { public boolean verify(byte[] message, byte[] signature) { Util.checkLength(signature, SIGNATURE_BYTES); byte[] sigAndMsg = Util.merge(signature, message); byte[] buffer = Util.zeros(sigAndMsg.length); int[] bufferLen = new int[1]; return Util.isValid(sodium().crypto_sign_ed25519_open(buffer, bufferLen, sigAndMsg, sigAndMsg.length, key), "signature was forged or corrupted"); } VerifyKey(byte[] key); VerifyKey(String key, Encoder encoder); boolean verify(byte[] message, byte[] signature); boolean verify(String message, String signature, Encoder encoder); byte[] toBytes(); @Override String toString(); }### Answer: @Test public void testVerifyCorrectRawSignature() throws Exception { byte[] rawSignature = HEX.decode(SIGN_SIGNATURE); byte[] rawMessage = HEX.decode(SIGN_MESSAGE); byte[] rawPublicKey = HEX.decode(SIGN_PUBLIC); VerifyKey verifyKey = new VerifyKey(rawPublicKey); assertTrue(verifyKey.verify(rawMessage, rawSignature)); } @Test public void testVerifyCorrectHexSignature() throws Exception { byte[] rawPublicKey = HEX.decode(SIGN_PUBLIC); VerifyKey verifyKey = new VerifyKey(rawPublicKey); verifyKey.verify(SIGN_MESSAGE, SIGN_SIGNATURE, HEX); assertTrue(verifyKey.verify(SIGN_MESSAGE, SIGN_SIGNATURE, HEX)); } @Test public void testDetectBadSignature() throws Exception { try { String badSignature = SIGN_SIGNATURE.concat("0000"); VerifyKey verifyKey = new VerifyKey(SIGN_PUBLIC, HEX); verifyKey.verify(SIGN_MESSAGE, badSignature, HEX); fail("Should an exception on bad signatures"); } catch (Exception e) { assertTrue(true); } } @Test public void testInitializeFromHex() throws Exception { VerifyKey verifyKey = new VerifyKey(SIGN_PUBLIC, HEX); assertTrue(verifyKey.verify(SIGN_MESSAGE, SIGN_SIGNATURE, HEX)); }
### Question: KeyPair { public PublicKey getPublicKey() { Point point = new Point(); byte[] key = publicKey != null ? publicKey : point.mult(secretKey).toBytes(); return new PublicKey(key); } KeyPair(); KeyPair(byte[] seed); KeyPair(String secretKey, Encoder encoder); PublicKey getPublicKey(); PrivateKey getPrivateKey(); }### Answer: @Test public void testGeneratePublicKey() throws Exception { try { byte[] pk = HEX.decode(BOB_PRIVATE_KEY); KeyPair key = new KeyPair(pk); assertTrue(key.getPublicKey() != null); } catch (Exception e) { fail("Should return a valid key size"); } } @Test public void testPrivateKeyToBytes() throws Exception { try { KeyPair key = new KeyPair(HEX.decode(BOB_SEED)); assertTrue("Correct private key expected", Arrays.equals(HEX.decode(BOB_ENCRYPTION_PUBLIC_KEY), key.getPublicKey().toBytes())); } catch (Exception e) { fail("Should return a valid key size"); } } @Test public void testPublicKeyToString() throws Exception { try { KeyPair key = new KeyPair(HEX.decode(BOB_SEED)); assertEquals("Correct public key expected", BOB_ENCRYPTION_PUBLIC_KEY, key.getPublicKey().toString()); } catch (Exception e) { fail("Should return a valid key size"); } } @Test public void testPublicKeyToBytes() throws Exception { try { KeyPair key = new KeyPair(HEX.decode(BOB_SEED)); assertTrue("Correct public key expected", Arrays.equals(HEX.decode(BOB_ENCRYPTION_PUBLIC_KEY), key.getPublicKey().toBytes())); } catch (Exception e) { fail("Should return a valid key size"); } }
### Question: KeyPair { public PrivateKey getPrivateKey() { return new PrivateKey(secretKey); } KeyPair(); KeyPair(byte[] seed); KeyPair(String secretKey, Encoder encoder); PublicKey getPublicKey(); PrivateKey getPrivateKey(); }### Answer: @Test public void testPrivateKeyToString() throws Exception { try { KeyPair key = new KeyPair(HEX.decode(BOB_SEED)); assertEquals("Correct private key expected", BOB_ENCRYPTION_PRIVATE_KEY, key.getPrivateKey().toString()); } catch (Exception e) { fail("Should return a valid key size"); } }
### Question: DecisionDiscovery { public Set<Class<?>> discover(String packagePrefix) { Reflections reflections = new Reflections(new ConfigurationBuilder() .setUrls(ClasspathHelper.forPackage(packagePrefix)) .filterInputsBy(new FilterBuilder().includePackage(packagePrefix)) ); return reflections.getTypesAnnotatedWith(DRGElement.class); } Set<Class<?>> discover(String packagePrefix); }### Answer: @Test public void testDiscovery() { Set<Class<?>> decisions = decisionDiscovery.discover("com.gs"); assertEquals(1, decisions.size()); Class<?> first = decisions.iterator().next(); assertEquals("com.gs.dmn.runtime.discovery.NopDecision", first.getName()); }
### Question: MetadataValidator { public boolean validate(String pkg, ClassLoader classLoader) { String metadataPath = pkg.replace('.', '/'); String fileName = DMNMetadata.class.getSimpleName(); try (InputStream metadataStream = classLoader.getResourceAsStream(String.format("%s/%s.json", metadataPath, fileName))) { DMNMetadata dmnMetadata = JsonSerializer.OBJECT_MAPPER.readValue(metadataStream, DMNMetadata.class); List<DRGElement> decisions = dmnMetadata.getDecisions(); for (DRGElement decision : decisions) { String className = String.format("%s", decision.getJavaTypeName()); Class<?> aClass = Class.forName(className, true, classLoader); boolean isGenerated = isGenerated(aClass); if (!isGenerated) { return false; } } return true; } catch (Exception e) { LOGGER.debug(e.getMessage()); return false; } } boolean validate(String pkg, ClassLoader classLoader); }### Answer: @Test public void testMetadata() { assertEquals("Invalid metadata", false, validator.validate("com.gs.dmn.runtime.metadata", this.getClass().getClassLoader())); }
### Question: MixedJavaTimeDMNBaseDecision extends MixedJavaTimeFEELLib implements DMNDecision<BigDecimal, LocalDate, OffsetTime, ZonedDateTime, Duration>, AnnotationTarget { @Override public DRGElement getDRGElementAnnotation() { return this.getClass().getAnnotation(DRGElement.class); } @Override DRGElement getDRGElementAnnotation(); @Override Rule getRuleAnnotation(int ruleIndex); }### Answer: @Test public void testGetDRGElementAnnotation() { DRGElement drgElementAnnotation = baseDecision.getDRGElementAnnotation(); assertNull(drgElementAnnotation); }
### Question: UniqueNameValidator extends SimpleDMNValidator { @Override public List<String> validate(DMNModelRepository dmnModelRepository) { List<String> errors = new ArrayList<>(); if (dmnModelRepository == null) { throw new IllegalArgumentException("Missing definitions"); } for (TDefinitions definitions: dmnModelRepository.getAllDefinitions()) { logger.debug("Validate unique 'DRGElement.name'"); validateUnique( "DRGElement", "name", false, new ArrayList<>(dmnModelRepository.findDRGElements(definitions)), TNamedElement::getName, null, errors ); logger.debug("Validate unique 'ItemDefinition.name'"); validateUnique( "ItemDefinition", "name", false, new ArrayList<>(dmnModelRepository.findItemDefinitions(definitions)), TNamedElement::getName, null, errors ); } return errors; } UniqueNameValidator(); UniqueNameValidator(BuildLogger logger); @Override List<String> validate(DMNModelRepository dmnModelRepository); }### Answer: @Test public void testValidateWhenCorrect() { validate(validator, "tck/cl3/input/0020-vacation-days.dmn", new ArrayList<>()); } @Test public void testValidateDefinitionsWhenNotUniqueNames() { List<String> expectedErrors = Arrays.asList( "The 'name' of a 'DRGElement' must be unique. Found 3 duplicates for 'CIP Assessments'.", "The 'name' of a 'DRGElement' must be unique. Found 2 duplicates for 'Input'.", "The 'name' of a 'ItemDefinition' must be unique. Found 2 duplicates for 'itemDefinition'." ); validate(validator, "dmn/input/test-dmn-with-duplicates.dmn", expectedErrors); } @Test(expected = IllegalArgumentException.class) public void testValidateDefinitionsWhenNull() { validator.validate(null); }
### Question: TypeRefValidator extends SimpleDMNValidator { @Override public List<String> validate(DMNModelRepository dmnModelRepository) { if (dmnModelRepository == null) { throw new IllegalArgumentException("Missing definitions"); } List<Pair<TDRGElement, Type>> errorReport = makeErrorReport(dmnModelRepository); return errorReport.stream().map(p -> makeError(p, dmnModelRepository)).collect(Collectors.toList()); } TypeRefValidator(); TypeRefValidator(BuildLogger logger); TypeRefValidator(DMNDialectDefinition<?, ?, ?, ?, ?, ?> dmnDialectDefinition); @Override List<String> validate(DMNModelRepository dmnModelRepository); List<Pair<TDRGElement, Type>> makeErrorReport(DMNModelRepository dmnModelRepository); }### Answer: @Test public void testValidateWhenCorrect() { List<String> expectedErrors = Arrays.asList(); validate(validator, "tck/cl3/input/0020-vacation-days.dmn", expectedErrors); } @Test public void validate() { List<String> expectedErrors = Arrays.asList( "Error:(label='Applicant', name='applicant', id='id-d2376567fde3c9400ee327ecec21e36d') Cannot find typeRef 'QualifiedName(null, applicant)'" ); validate(validator, "dmn/input/test-dmn-with-missing-type-ref.dmn", expectedErrors); } @Test(expected = IllegalArgumentException.class) public void testValidateDefinitionsWhenNull() { validator.validate(null); }
### Question: MixedJavaTimeDMNBaseDecision extends MixedJavaTimeFEELLib implements DMNDecision<BigDecimal, LocalDate, OffsetTime, ZonedDateTime, Duration>, AnnotationTarget { @Override public Rule getRuleAnnotation(int ruleIndex) { String methodName = String.format("rule%d", ruleIndex); Class<? extends MixedJavaTimeDMNBaseDecision> cls = this.getClass(); Method[] declaredMethods = cls.getDeclaredMethods(); for (Method method : declaredMethods) { if (methodName.equals(method.getName())) { return method.getAnnotation(Rule.class); } } return null; } @Override DRGElement getDRGElementAnnotation(); @Override Rule getRuleAnnotation(int ruleIndex); }### Answer: @Test public void testGetRuleAnnotation() { Rule ruleAnnotation = baseDecision.getRuleAnnotation(0); assertNull(ruleAnnotation); }
### Question: UniqueInformationRequirementValidator extends SimpleDMNValidator { @Override public List<String> validate(DMNModelRepository dmnModelRepository) { List<String> errors = new ArrayList<>(); if (dmnModelRepository == null) { throw new IllegalArgumentException("Missing definitions"); } for (TDefinitions definitions: dmnModelRepository.getAllDefinitions()) { for (TDRGElement element : dmnModelRepository.findDRGElements(definitions)) { if (element instanceof TDecision) { List<TInformationRequirement> irList = ((TDecision) element).getInformationRequirement(); validate(getReferences(irList), element, "InformationRequirement", errors); } else if (element instanceof TDecisionService) { List<TDMNElementReference> inputData = ((TDecisionService) element).getInputData(); validate(inputData, element, "InputData", errors); List<TDMNElementReference> inputDecision = ((TDecisionService) element).getInputDecision(); validate(inputDecision, element, "InputDecision", errors); } } } return errors; } UniqueInformationRequirementValidator(); UniqueInformationRequirementValidator(BuildLogger logger); @Override List<String> validate(DMNModelRepository dmnModelRepository); }### Answer: @Test public void testValidateWhenCorrect() { validate(validator, "tck/cl3/input/0020-vacation-days.dmn", new ArrayList<>()); } @Test public void testValidateDefinitionsWhenNotUniqueNames() { List<String> expectedErrors = Arrays.asList( "Duplicated InformationRequirement 'decision-1' in element 'CIP Assessments'", "Duplicated InformationRequirement 'input-1' in element 'CIP Assessments'" ); validate(validator, "dmn/input/test-dmn-with-duplicated-information-requirements.dmn", expectedErrors); } @Test(expected = IllegalArgumentException.class) public void testValidateDefinitionsWhenNull() { validator.validate(null); }
### Question: GoogleJavaFormatter implements JavaFormatter { @Override public String formatSource(String code) { try { return FORMATTER.formatSource(code); } catch (FormatterException e) { throw new DMNRuntimeException("Failed to format java", e); } } @Override String formatSource(String code); }### Answer: @Test public void testFormatSource() throws Exception { doTest(); }
### Question: ToQuotedNameTransformer extends NameTransformer { @Override public String transformName(String name) { if (StringUtils.isEmpty(name)) { return name; } else if (isSimpleName(name)) { return name; } else { return "'" + name + "'"; } } ToQuotedNameTransformer(); ToQuotedNameTransformer(BuildLogger logger); @Override String transformName(String name); }### Answer: @Test public void testTransformName() { ToQuotedNameTransformer transformer = (ToQuotedNameTransformer) getTransformer(); String firstName = transformer.transformName("abc ? x"); assertEquals("'abc ? x'", firstName); String secondName = transformer.transformName("abc?x"); assertEquals("'abc?x'", secondName); String result = transformer.transformName("a \uD83D\uDC0E bc"); assertEquals("'a \uD83D\uDC0E bc'", result); }
### Question: ToSimpleNameTransformer extends NameTransformer { @Override public String transformName(String oldName) { if (StringUtils.isEmpty(oldName)) { return oldName; } else if (isSimpleName(oldName)) { return oldName; } else { String newName = namesMapping.get(oldName); if (newName == null) { newName = toSimpleName(oldName); if (!newName.equals(oldName)) { boolean isDuplicate = false; for(String key: namesMapping.keys()) { if (!key.equals(oldName) && newName.equals(namesMapping.get(key))) { isDuplicate = true; break; } } if (isDuplicate) { newName = newName + "_" + ++counter; } namesMapping.put(oldName, newName); } } return newName; } } ToSimpleNameTransformer(); ToSimpleNameTransformer(BuildLogger logger); @Override String transformName(String oldName); static void main(String[] args); }### Answer: @Test public void testTransformName() { ToSimpleNameTransformer transformer = (ToSimpleNameTransformer) getTransformer(); String firstName = transformer.transformName("abc ? x"); assertEquals("abcX", firstName); String secondName = transformer.transformName("abc?x"); assertEquals("abcX_1", secondName); String result = transformer.transformName("a \uD83D\uDC0E bc"); assertEquals("aBc", result); }
### Question: QualifiedName { public static QualifiedName toQualifiedName(TDefinitions model, String qName) { if (qName == null || qName.isEmpty()) { return null; } if (qName.startsWith(DMNVersion.LATEST.getFeelPrefix() + ".")) { String prefix = DMNVersion.LATEST.getFeelPrefix(); String localPart = qName.substring(qName.indexOf('.') + 1); return new QualifiedName(prefix, localPart); } if (model == null) { return new QualifiedName(null, qName); } else { for (TImport import_: model.getImport()) { String importName = import_.getName(); if (qName.startsWith(importName + '.')) { String localPart = qName.substring(qName.indexOf('.') + 1); return new QualifiedName(importName, localPart); } } return new QualifiedName(null, qName); } } private QualifiedName(String namespace, String localPart); static QualifiedName toQualifiedName(TDefinitions model, String qName); String getNamespace(); String getLocalPart(); @Override String toString(); }### Answer: @Test public void testConstructorWithNullString() { QualifiedName qualifiedName = QualifiedName.toQualifiedName(null, null); assertNull(qualifiedName); } @Test public void testConstructorWithEmptyString() { QualifiedName qualifiedName = QualifiedName.toQualifiedName(null, ""); assertNull(qualifiedName); }
### Question: AddMissingImportPrefixInDTTransformer extends SimpleDMNTransformer<TestCases> { private void addMissingPrefix(TLiteralExpression exp, Set<String> names) { if (exp != null) { String newText = addMissingPrefix(exp.getText(), names); exp.setText(newText); } } AddMissingImportPrefixInDTTransformer(); AddMissingImportPrefixInDTTransformer(BuildLogger logger); @Override DMNModelRepository transform(DMNModelRepository repository); @Override Pair<DMNModelRepository, List<TestCases>> transform(DMNModelRepository repository, List<TestCases> testCases); }### Answer: @Test public void testAddMissingPrefix() { List<Pair<String, String>> testCases = Arrays.asList( new Pair<>(null, null), new Pair<>("", ""), new Pair<>("\"ident1\"", "\"ident1\""), new Pair<>("ident1+ident2", "ident1.ident1 + ident2.ident2"), new Pair<>("> ident1+ident2", "> ident1.ident1 + ident2.ident2"), new Pair<>("starts with(?, ident1)", "starts with ( ? , ident1.ident1 )"), new Pair<>("ident1(?, ident1)", "ident1 ( ? , ident1.ident1 )"), new Pair<>("ident1.ident1+4", "ident1.ident1 . ident1 + 4") ); for (Pair<String, String> pair: testCases) { String text = pair.getLeft(); String newText = transformer.addMissingPrefix(text, names); assertEquals(pair.getRight(), newText); } }
### Question: SparseDecisionDetector extends SimpleLazyEvaluationDetector { boolean isSparseDecisionTable(TDecisionTable expression, double sparsityThreshold) { int columnNo = expression.getInput().size(); int lineNo = expression.getRule().size(); int anyMatchCount = 0; for(TDecisionRule rule: expression.getRule()) { for(TUnaryTests test : rule.getInputEntry()) { if ("-".equals(test.getText())) { anyMatchCount++; } } } double sparsity = 1.0 * anyMatchCount / (lineNo * columnNo); return sparsity >= sparsityThreshold; } SparseDecisionDetector(); SparseDecisionDetector(Map<String, String> inputParameters, BuildLogger logger); @Override LazyEvaluationOptimisation detect(DMNModelRepository modelRepository); }### Answer: @Test public void testIsSparseDecisionTable() { TDefinitions definitions = this.dmnModelRepository.getRootDefinitions(); checkDecisionTable(dmnModelRepository.findDRGElementByName(definitions, "EligibilityRules"), 0.75, true); checkDecisionTable(dmnModelRepository.findDRGElementByName(definitions, "Strategy"), 0.75, false); }
### Question: FieldType { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; FieldType fieldType = (FieldType) o; if (modifier != null ? !modifier.equals(fieldType.modifier) : fieldType.modifier != null) return false; return type != null ? type.equals(fieldType.type) : fieldType.type == null; } FieldType(String modifier, String type); String getType(); String getModifier(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testEquals() { FieldType ft1 = new FieldType("optional", "string"); FieldType ft2 = new FieldType("optional", "string"); assertEquals(ft1, ft2); }
### Question: FieldType { @Override public int hashCode() { int result = modifier != null ? modifier.hashCode() : 0; result = 31 * result + (type != null ? type.hashCode() : 0); return result; } FieldType(String modifier, String type); String getType(); String getModifier(); @Override boolean equals(Object o); @Override int hashCode(); }### Answer: @Test public void testHasCode() { FieldType ft1 = new FieldType("optional", "string"); assertEquals(953450673, ft1.hashCode()); }