Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: LinearCongruentialRandom extends AbstractBoxMuller { @Override public float nextFloat() { return (float) nextDouble(); } LinearCongruentialRandom(final long theSeed); LinearCongruentialRandom(); LinearCongruentialRandom(final long theModulus, final long theMultiplier, final long theIncrement, final long theSeed); final long getIncrement(); final long getModulus(); final long getMultiplier(); final long getSeed(); @Override final double nextDouble(); @Override final long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); static final long DEFAULT_MOD1; static final long DEFAULT_MOD2; static final long DEFAULT_MULT; static final long DEFAULT_INC; static final long MAX_RAND; }### Answer: @Test public void testFloat() { final LinearCongruentialRandom rnd = new LinearCongruentialRandom(1); for (final float aFLOAT_TEST : FLOAT_TEST) { final float l = (float) rnd.nextFloat(); assertEquals(l, aFLOAT_TEST, AIFH.DEFAULT_PRECISION); } }
### Question: LinearCongruentialRandom extends AbstractBoxMuller { @Override public int nextInt() { return (int) nextLong(); } LinearCongruentialRandom(final long theSeed); LinearCongruentialRandom(); LinearCongruentialRandom(final long theModulus, final long theMultiplier, final long theIncrement, final long theSeed); final long getIncrement(); final long getModulus(); final long getMultiplier(); final long getSeed(); @Override final double nextDouble(); @Override final long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); static final long DEFAULT_MOD1; static final long DEFAULT_MOD2; static final long DEFAULT_MULT; static final long DEFAULT_INC; static final long MAX_RAND; }### Answer: @Test public void testInt() { final LinearCongruentialRandom rnd = new LinearCongruentialRandom(1); for (final int aINT_TEST : INT_TEST) { final int g = rnd.nextInt(); assertEquals(g, aINT_TEST, AIFH.DEFAULT_PRECISION); } } @Test public void testIntRange() { final LinearCongruentialRandom rnd = new LinearCongruentialRandom(1); for (final int aINT_RANGE_TEST : INT_RANGE_TEST) { final int g = rnd.nextInt(0, 10); assertEquals(g, aINT_RANGE_TEST); } }
### Question: MersenneTwisterGenerateRandom extends AbstractBoxMuller { @Override public double nextDouble() { return (((long) next(26) << 27) + next(27)) / (double) (1L << 53); } MersenneTwisterGenerateRandom(); MersenneTwisterGenerateRandom(final long seed); MersenneTwisterGenerateRandom(final int[] array); void setSeed(final long seed); void setSeed(final int[] array); @Override double nextDouble(); long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }### Answer: @Test public void testBasic() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); assertEquals(4.1702200468159925, rnd.nextDouble(10), AIFH.DEFAULT_PRECISION); } @Test public void testBasic2() { final int[] seed = {1, 2, 3}; final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(seed); assertEquals(6.09861274980219, rnd.nextDouble(10), AIFH.DEFAULT_PRECISION); } @Test public void testDoubleRange() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final double aDOUBLE_RANGE_TEST : DOUBLE_RANGE_TEST) { final double g = rnd.nextDouble(-1, 1); assertEquals(g, aDOUBLE_RANGE_TEST, AIFH.DEFAULT_PRECISION); } } @Test public void testDouble() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final double aDOUBLE_TEST : DOUBLE_TEST) { final double g = rnd.nextDouble(); assertEquals(g, aDOUBLE_TEST, AIFH.DEFAULT_PRECISION); } }
### Question: MersenneTwisterGenerateRandom extends AbstractBoxMuller { @Override public boolean nextBoolean() { return nextDouble() > 0.5; } MersenneTwisterGenerateRandom(); MersenneTwisterGenerateRandom(final long seed); MersenneTwisterGenerateRandom(final int[] array); void setSeed(final long seed); void setSeed(final int[] array); @Override double nextDouble(); long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }### Answer: @Test public void testGenerateBoolean() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final boolean aBOOLEAN_TEST : BOOLEAN_TEST) { final boolean g = rnd.nextBoolean(); assertEquals(g, aBOOLEAN_TEST); } }
### Question: MersenneTwisterGenerateRandom extends AbstractBoxMuller { public long nextLong() { return ((long) next(32) << 32) + next(32); } MersenneTwisterGenerateRandom(); MersenneTwisterGenerateRandom(final long seed); MersenneTwisterGenerateRandom(final int[] array); void setSeed(final long seed); void setSeed(final int[] array); @Override double nextDouble(); long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }### Answer: @Test public void testLong() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final long aLONG_TEST : LONG_TEST) { final long l = rnd.nextLong(); assertEquals(l, aLONG_TEST); } }
### Question: MersenneTwisterGenerateRandom extends AbstractBoxMuller { @Override public float nextFloat() { return (float) nextDouble(); } MersenneTwisterGenerateRandom(); MersenneTwisterGenerateRandom(final long seed); MersenneTwisterGenerateRandom(final int[] array); void setSeed(final long seed); void setSeed(final int[] array); @Override double nextDouble(); long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }### Answer: @Test public void testFloat() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final float aFLOAT_TEST : FLOAT_TEST) { final float l = (float) rnd.nextFloat(); assertEquals(l, aFLOAT_TEST, AIFH.DEFAULT_PRECISION); } }
### Question: ManhattanDistance extends AbstractDistance { @Override public double calculate(final double[] position1, final int pos1, final double[] position2, final int pos2, final int length) { double sum = 0; for (int i = 0; i < length; i++) { final double d = Math.abs(position1[pos1 + i] - position2[pos1 + i]); sum += d; } return sum; } @Override double calculate(final double[] position1, final int pos1, final double[] position2, final int pos2, final int length); }### Answer: @Test public void testDistanceCalc() { final CalculateDistance calc = new ManhattanDistance(); final double[] pos1 = {0.5, 1.0, 2.5,}; final double[] pos2 = {0.1, 2.0, -2.5,}; assertEquals(6.4, calc.calculate(pos1, pos2), 0.001); }
### Question: MersenneTwisterGenerateRandom extends AbstractBoxMuller { @Override public int nextInt() { return (int) nextLong(); } MersenneTwisterGenerateRandom(); MersenneTwisterGenerateRandom(final long seed); MersenneTwisterGenerateRandom(final int[] array); void setSeed(final long seed); void setSeed(final int[] array); @Override double nextDouble(); long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }### Answer: @Test public void testInt() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final int aINT_TEST : INT_TEST) { final int g = rnd.nextInt(); assertEquals(g, aINT_TEST); } } @Test public void testIntRange() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final int aINT_RANGE_TEST : INT_RANGE_TEST) { final int g = rnd.nextInt(0, 10); assertEquals(g, aINT_RANGE_TEST); } }
### Question: XaiverRandomizeNetwork extends AbstractRandomizeNetwork { @Override public void randomize(BasicNetwork network) { for (int i = 0; i < network.getLayers().size() - 1; i++) { randomizeLayer(network, i); } } @Override void randomize(BasicNetwork network); }### Answer: @Test public void testRandomize() { BasicNetwork network = new BasicNetwork(); network.addLayer(new BasicLayer(null,true,2)); network.addLayer(new BasicLayer(new ActivationSigmoid(),true,3)); network.addLayer(new BasicLayer(new ActivationSigmoid(),false,1)); network.finalizeStructure(); XaiverRandomizeNetwork randomize = new XaiverRandomizeNetwork(); randomize.setRnd(new LinearCongruentialRandom(10)); randomize.randomize(network); double[] expected = {-0.48063016461488856, -0.6268874420756946, 3.2098992119169534E-4, -0.1914041699971798, 1.040596563646283, -0.485186340462527, -1.110171460956511, -1.0430309621862426, -0.13325874823843634, -0.18257850835630843, 0.228311697697274, 0.2916967306617774, -0.43452699284274987}; Assert.assertArrayEquals(expected,network.getWeights(), AIFH.DEFAULT_PRECISION); }
### Question: KMeans { public void initRandom(final List<BasicData> theObservations) { final int dimensions = findDimensions(theObservations); for (int i = 0; i < this.k; i++) { this.clusters.add(new Cluster(dimensions)); } for (final BasicData observation : theObservations) { final int clusterIndex = this.randomGeneration.nextInt(this.k); final Cluster cluster = this.clusters.get(clusterIndex); cluster.getObservations().add(observation); } for (final Cluster cluster : this.clusters) { if (cluster.getObservations().size() == 0) { boolean done = false; while (!done) { final int sourceIndex = this.randomGeneration.nextInt(this.k); final Cluster source = this.clusters.get(sourceIndex); if (source != cluster && source.getObservations().size() > 1) { final int sourceObservationIndex = this.randomGeneration.nextInt(source.getObservations().size()); final BasicData sourceObservation = source.getObservations().get(sourceObservationIndex); source.getObservations().remove(sourceObservationIndex); cluster.getObservations().add(sourceObservation); done = true; } } } } updateStep(); } KMeans(final int theK); void initRandom(final List<BasicData> theObservations); void initForgy(final List<BasicData> theObservations); Cluster findNearestCluster(final double[] observation); boolean iteration(); int iteration(final int maxIterations); GenerateRandom getRandomGeneration(); void setRandomGeneration(final GenerateRandom randomGeneration); CalculateDistance getDistanceMetric(); void setDistanceMetric(final CalculateDistance distanceMetric); int getK(); List<Cluster> getClusters(); }### Answer: @Test(expected = AIFHError.class) public void testTooManyClusters() { final KMeans kmeans = new KMeans(13); kmeans.initRandom(getDataSet()); }
### Question: KMeans { public boolean iteration() { if (this.clusters.size() == 0) { throw new AIFHError("Must call one of the init methods first."); } final boolean done = assignmentStep(); if (!done) { updateStep(); } return done; } KMeans(final int theK); void initRandom(final List<BasicData> theObservations); void initForgy(final List<BasicData> theObservations); Cluster findNearestCluster(final double[] observation); boolean iteration(); int iteration(final int maxIterations); GenerateRandom getRandomGeneration(); void setRandomGeneration(final GenerateRandom randomGeneration); CalculateDistance getDistanceMetric(); void setDistanceMetric(final CalculateDistance distanceMetric); int getK(); List<Cluster> getClusters(); }### Answer: @Test(expected = AIFHError.class) public void testEarlyIteration() { final KMeans kmeans = new KMeans(3); kmeans.iteration(); }
### Question: AvailableBuildsList { public synchronized List<BranchBuilds> getBranchBuildsList() { return branchBuildsList; } synchronized List<BranchBuilds> getBranchBuildsList(); synchronized BranchBuilds getBranchBuilds(final String branchName); synchronized void updateBuildsWithSuccessfullyImportedBuilds(final List<BranchBuilds> branchBuildsList, final Map<BuildIdentifier, BuildImportSummary> buildImportSummaries); synchronized void refreshAliases(); synchronized void addImportedBuild(final BuildImportSummary buildImportSummary); void removeBuild(final BuildIdentifier buildIdentifier); String resolveAliasBuildName(final String branchName, final String buildName); void logAvailableBuildsInformation(); }### Answer: @Test void testInitializedEmpty() { assertEquals(0, availableBuildsList.getBranchBuildsList().size(), "Expected initialized as empty list"); }
### Question: BuildSorter implements Comparator<BuildLink> { public static void sort(final List<BuildLink> builds) { Collections.sort(builds, new BuildSorter()); } static void sort(final List<BuildLink> builds); @Override int compare(final BuildLink bl1, final BuildLink bl2); }### Answer: @Test void testSortingSomeBuilds() { BuildLink build1 = createBuildSuccess("build1", 1); BuildLink build2 = createBuildSuccess("build2", 2); BuildLink build3 = createBuildFailed("build3", 3); BuildLink aliasCurrent = createBuildAlias(Configuration.DEFAULT_ALIAS_FOR_LAST_SUCCESSFUL_BUILD, build2.getBuild()); BuildLink aliasLast = createBuildAlias(Configuration.DEFAULT_ALIAS_FOR_MOST_RECENT_BUILD, build3.getBuild()); List<BuildLink> buildsList = Arrays.asList(build1, build2, build3, aliasCurrent, aliasLast); BuildSorter.sort(buildsList); assertSame(aliasCurrent, buildsList.get(0), "default build alias 'current' expected as first element"); assertSame(aliasLast, buildsList.get(1), "build alias 'last' expected as second element"); assertSame(build3, buildsList.get(2), "build3 expected as first non-aliased build (builds sorted by dates decreasing)"); assertSame(build1, buildsList.get(4), "build1 expected as last non-aliased build (builds sorted by dates decreasing)"); }
### Question: ComparisonExecutor { public boolean areAllComparisonCalculationsFinished() { return asyncComparisonExecutor.getActiveCount() == 0; } ComparisonExecutor(AliasResolver aliasResolver); ComparisonExecutor(ThreadPoolExecutor executorService, AliasResolver aliasResolver); void scheduleAllConfiguredComparisonsForOneBuild(String baseBranchName, String baseBuildName); Future<BuildDiffInfo> scheduleComparison(String baseBranchName, String baseBuildName, String comparisonBranchName, String comparisonBuildName, String comparisonName); void executeAfterAllPendingComparisonsDone(Runnable task); boolean areAllComparisonCalculationsFinished(); }### Answer: @Test void testAreAllComparisonCalculationsFinishedWithNoRunningThreadsReturnsTrue() { when(threadPoolExecutor.getActiveCount()).thenReturn(0); assertTrue(comparisonExecutor.areAllComparisonCalculationsFinished()); } @Test void testAreAllComparisonCalculationsFinishedWithRunningThreadsReturnsFalse() { when(threadPoolExecutor.getActiveCount()).thenReturn(1); assertFalse(comparisonExecutor.areAllComparisonCalculationsFinished()); }
### Question: PageNameSanitizer { public static void sanitizePageName(final Step step) { if (step == null \|\| step.getPage() == null) { return; } step.getPage().setName(sanitize(step.getPage().getName())); } static void sanitizePageNames(final List<Step> steps); static void sanitizePageName(final Step step); }### Answer: @Test void givenStepWithIllegalPageName_sanitizingPageNames_replacesIllegalCharacters() { Step step = getStepWithIllegalPageName(); PageNameSanitizer.sanitizePageName(step); assertEquals(SANITIZED, step.getPage().getName()); }
### Question: PageNameSanitizer { public static void sanitizePageNames(final List<Step> steps) { if (steps == null) { return; } for (Step step : steps) { sanitizePageName(step); } } static void sanitizePageNames(final List<Step> steps); static void sanitizePageName(final Step step); }### Answer: @Test void givenStepListWithIllegalPageNames_sanitizingPageNames_replacesIllegalCharacters() { List<Step> steps = getStepsWithIllegalPageName(); PageNameSanitizer.sanitizePageNames(steps); assertEquals(SANITIZED, steps.get(0).getPage().getName()); assertEquals(SANITIZED, steps.get(1).getPage().getName()); }
### Question: ScenarioPageSteps { public int getTotalNumberOfStepsInPageOccurrence(final String pageName, final int pageOccurrence) { PageSteps pageWithSteps = getOccurrence(pageName, pageOccurrence); if (pageWithSteps == null) { return 0; } return pageWithSteps.getSteps().size(); } Scenario getScenario(); void setScenario(final Scenario scenario); ScenarioStatistics getScenarioStatistics(); UseCase getUseCase(); void setUseCase(final UseCase useCase); List<PageSteps> getPagesAndSteps(); void setPagesAndSteps(final List<PageSteps> pagesAndSteps); int getTotalNumberOfStepsInScenario(); StepStatistics getStepStatistics(final String pageName, final int pageOccurrence); int getTotalNumberOfStepsInPageOccurrence(final String pageName, final int pageOccurrence); StepDescription getStepDescription(final String pageName, final int pageOccurrence, final int stepInPageOccurrence); }### Answer: @Test void getTotalNumberOfStepsInPageOccurrence() { givenScenarioPagesAndSteps(); whenGettingTotalStepsForPage1SecondOccurrence(); expectTotalNumberOfStepsEquals(4); }
### Question: ScenarioPageSteps { public StepStatistics getStepStatistics(final String pageName, final int pageOccurrence) { StepStatistics statistics = new StepStatistics(); statistics.setTotalNumberOfStepsInScenario(getTotalNumberOfStepsInScenario()); statistics .setTotalNumberOfStepsInPageOccurrence(getTotalNumberOfStepsInPageOccurrence(pageName, pageOccurrence)); statistics.setTotalNumberOfPagesInScenario(getTotalNumberOfPagesInScenario()); return statistics; } Scenario getScenario(); void setScenario(final Scenario scenario); ScenarioStatistics getScenarioStatistics(); UseCase getUseCase(); void setUseCase(final UseCase useCase); List<PageSteps> getPagesAndSteps(); void setPagesAndSteps(final List<PageSteps> pagesAndSteps); int getTotalNumberOfStepsInScenario(); StepStatistics getStepStatistics(final String pageName, final int pageOccurrence); int getTotalNumberOfStepsInPageOccurrence(final String pageName, final int pageOccurrence); StepDescription getStepDescription(final String pageName, final int pageOccurrence, final int stepInPageOccurrence); }### Answer: @Test void getStepStatistics() { givenScenarioPagesAndSteps(); whenGettingPageStatisticsForPage1SecondOccurrence(); expectTotalNumberOfStepsInStatisticsEquals(7); expectTotalNumberOfStepsInPageOccurrenceInStatisticsEquals(4); expectTotalNumberOfPagesInScenarioInStatisticsEquals(3); }
### Question: NumberFormatter { public static final String formatMinimumThreeDigits(long number) { if(number < 0) { throw new RuntimeException("Encountered a negative number, which must be a bug: " + number); } return NumberFormatter.createNumberFormatWithMinimumIntegerDigits(3).format(number); } static final String formatMinimumThreeDigits(long number); }### Answer: @Test void formatMinimumThreeDigits_positiveNumbersAndZero_returnsFormattedNumber() { assertEquals("000", NumberFormatter.formatMinimumThreeDigits(0)); assertEquals("001", NumberFormatter.formatMinimumThreeDigits(1)); assertEquals("999", NumberFormatter.formatMinimumThreeDigits(999)); assertEquals("1000", NumberFormatter.formatMinimumThreeDigits(1000)); assertEquals("9223372036854775807", NumberFormatter.formatMinimumThreeDigits(Long.MAX_VALUE)); }
### Question: ScenariooDataPathLogic { String getDataPath(final ServletContext servletContext) { String configSource = "servlet context"; String configurationDirectory = servletContext.getInitParameter( "scenariooDataDirectory"); if (StringUtils.isBlank(configurationDirectory)) { configSource = "SCENARIOO_DATA environment variable or scenarioo.data application property"; configurationDirectory = systemEnvironment.getScenariooDataDirectory(); } if (StringUtils.isBlank(configurationDirectory)) { configSource = "default scenarioo data directory"; configurationDirectory = new File(systemEnvironment.getUserHome(), USER_HOME_BASE_DIRECTORY).getAbsolutePath(); } LOGGER.info(" Taking documentation data path from " + configSource + ": " + configurationDirectory); return configurationDirectory; } ScenariooDataPathLogic(final SystemEnvironment systemEnvironment); }### Answer: @Test void getDocumentationPath_GivenServletConfigAndEnvVariable_ChosesServletContextFirst() { when(servletContext.getInitParameter("scenariooDataDirectory")).thenReturn("tmp/test"); when(systemEnvironment.getScenariooDataDirectory()).thenReturn("tmp/itShouldNotBeMe"); String actual = logic.getDataPath(servletContext); assertEquals("tmp/test", actual); } @Test void getDocumentationPath_WhenServletContextParamIsNotPresent_ChosesEnvironmentVariable() { when(servletContext.getInitParameter("scenariooDataDirectory")).thenReturn(null); when(systemEnvironment.getScenariooDataDirectory()).thenReturn("tmp/test"); String actual = logic.getDataPath(servletContext); assertEquals("tmp/test", actual); } @Test void getDocumentationPath_WhenNoExternalConfigurationIsGiven_DefaultsToScenariooHomeFolder() { when(servletContext.getInitParameter("scenariooDataDirectory")).thenReturn(null); when(systemEnvironment.getScenariooDataDirectory()).thenReturn(null); when(systemEnvironment.getUserHome()).thenReturn("/home/someuser"); String expectedPath = new File("/home/someuser/.scenarioo").getAbsolutePath(); String actual = logic.getDataPath(servletContext); assertEquals(expectedPath, actual); }
### Question: IdGenerator { public static String generateRandomId() { UUID uuid = UUID.randomUUID(); return generateIdUsingHash(uuid.toString()); } static String generateRandomId(); static String generateIdUsingHash(final String value); }### Answer: @Test void randomIdHasLength8() { assertEquals(8, IdGenerator.generateRandomId().length()); } @Test void randomValuesAreAlwaysDifferent() { String first = IdGenerator.generateRandomId(); String second = IdGenerator.generateRandomId(); assertNotEquals(first, second); }
### Question: IdGenerator { public static String generateIdUsingHash(final String value) { MessageDigest converter; try { converter = MessageDigest.getInstance("SHA1"); String id = new String(Hex.encodeHex(converter.digest(value.getBytes()))); return id.substring(0, 8); } catch (final NoSuchAlgorithmException e) { LOGGER.info("Can't generate SHA1 hash code", e); throw new RuntimeException("Can't generate SHA1 hash code", e); } } static String generateRandomId(); static String generateIdUsingHash(final String value); }### Answer: @Test void allHashesAreOfLength8() { assertEquals(8, IdGenerator.generateIdUsingHash("").length()); assertEquals(8, IdGenerator.generateIdUsingHash("hello").length()); assertEquals(8, IdGenerator.generateIdUsingHash("hello world").length()); } @Test void hashOfNullString_throwsException() { assertThrows(NullPointerException.class, () -> IdGenerator.generateIdUsingHash(null)); } @Test void hashOfEmptyString() { assertEquals("da39a3ee", IdGenerator.generateIdUsingHash("")); } @Test void hashOfNonEmptyString() { assertEquals("3e3de94a", IdGenerator.generateIdUsingHash("Scenarioo")); }
### Question: FileSystemOperationsDao { public void deleteBuild(final BuildIdentifier buildIdentifier) { File buildFolder = getBuildFolder( buildIdentifier); if (!buildFolder.exists()) { LOGGER.debug("Build folder " + buildFolder.getAbsolutePath() + " does not exist, therefore it can't be deleted."); return; } try { FileUtils.deleteDirectory(buildFolder); LOGGER.info("Deleted build folder " + buildFolder.getAbsolutePath()); } catch (IOException e) { LOGGER.error("Can't delete build " + buildIdentifier, e); } } FileSystemOperationsDao(); void deleteBuild(final BuildIdentifier buildIdentifier); void createBuildFolderIfItDoesNotExist(final BuildIdentifier buildIdentifier); boolean buildFolderExists(final BuildIdentifier buildIdentifier); }### Answer: @Test void deleteBuild_deletesTheEntireBuildFolderWithAllSubfoldersAndFiles() { givenBuildFolderContainingSubfoldersAndFiles(); fileSystemOperationsDao.deleteBuild(buildIdentifier); expectBuildFolderIsDeleted(); expectBranchFolderStillExists(); }
### Question: FileSystemOperationsDao { public void createBuildFolderIfItDoesNotExist(final BuildIdentifier buildIdentifier) { File buildFolder = getBuildFolder(buildIdentifier); if (buildFolder.exists()) { LOGGER.debug("Build folder " + buildFolder.getAbsolutePath() + " already exists."); return; } buildFolder.mkdirs(); if (buildFolder.exists()) { LOGGER.info("Created build folder " + buildFolder.getAbsolutePath()); } else { LOGGER.error("Could not create build folder " + buildFolder.getAbsolutePath()); } } FileSystemOperationsDao(); void deleteBuild(final BuildIdentifier buildIdentifier); void createBuildFolderIfItDoesNotExist(final BuildIdentifier buildIdentifier); boolean buildFolderExists(final BuildIdentifier buildIdentifier); }### Answer: @Test void createBuildFolderIfItDoesNotExist_createsTheFolderBecauseIfItDoesNotExist() { givenBuildFolderDoesNotExist(); fileSystemOperationsDao.createBuildFolderIfItDoesNotExist(buildIdentifier); expectBuildFolderExists(); }
### Question: FullTextSearch { public void indexUseCases(final UseCaseScenariosList useCaseScenariosList, final BuildIdentifier buildIdentifier) { if(!searchAdapter.isEngineRunning()) { return; } searchAdapter.setupNewBuild(buildIdentifier); searchAdapter.indexUseCases(useCaseScenariosList, buildIdentifier); LOGGER.info("Indexed use cases for build " + buildIdentifier); } FullTextSearch(); FullTextSearch(final SearchAdapter search); boolean isEngineRunning(); String getEndpoint(); boolean isSearchEngineEndpointConfigured(); SearchTree search(SearchRequest searchRequest); void indexUseCases(final UseCaseScenariosList useCaseScenariosList, final BuildIdentifier buildIdentifier); void indexSteps(final List<Step> steps, final List<StepLink> stepLinkList, final Scenario scenario, final UseCase usecase, final BuildIdentifier buildIdentifier); void updateAvailableBuilds(final List<BuildImportSummary> availableBuilds); static final String STEP; static final String SCENARIO; static final String USECASE; }### Answer: @Test void indexUseCaseWithoutRunningEngine() { givenNoRunningEngine(); fullTextSearch.indexUseCases(new UseCaseScenariosList(), new BuildIdentifier("testBranch", "testBuild")); thenJustReturns(); }
### Question: FullTextSearch { public SearchTree search(SearchRequest searchRequest) { if(!searchAdapter.isEngineRunning()) { throw new SearchEngineNotRunningException(); } SearchResults searchResults; try { searchResults = searchAdapter.searchData(searchRequest); } catch (Throwable t) { throw new SearchFailedException(t); } return new SearchTree(searchResults, searchRequest); } FullTextSearch(); FullTextSearch(final SearchAdapter search); boolean isEngineRunning(); String getEndpoint(); boolean isSearchEngineEndpointConfigured(); SearchTree search(SearchRequest searchRequest); void indexUseCases(final UseCaseScenariosList useCaseScenariosList, final BuildIdentifier buildIdentifier); void indexSteps(final List<Step> steps, final List<StepLink> stepLinkList, final Scenario scenario, final UseCase usecase, final BuildIdentifier buildIdentifier); void updateAvailableBuilds(final List<BuildImportSummary> availableBuilds); static final String STEP; static final String SCENARIO; static final String USECASE; }### Answer: @Test void searchWithoutRunningEngine() { givenNoRunningEngine(); assertThrows(SearchEngineNotRunningException.class, ()->fullTextSearch.search(new SearchRequest(new BuildIdentifier("testBranch", "testBuild"), "hi", true))); } @Test void searchWithNoResults() { givenRunningEngineWithSearchResults(); SearchTree result = fullTextSearch.search(new SearchRequest(new BuildIdentifier("testBranch", "testBuild"), "IDONOTEXIST", true)); assertEquals(0, result.getResults().getChildren().size()); assertEquals(0, result.getTotalHits()); }
### Question: FullTextSearch { public void updateAvailableBuilds(final List<BuildImportSummary> availableBuilds) { if(!searchAdapter.isEngineRunning()) { return; } List<BuildIdentifier> existingBuilds = getAvailableBuildIdentifiers(availableBuilds); searchAdapter.updateAvailableBuilds(existingBuilds); LOGGER.info("Updated available builds."); } FullTextSearch(); FullTextSearch(final SearchAdapter search); boolean isEngineRunning(); String getEndpoint(); boolean isSearchEngineEndpointConfigured(); SearchTree search(SearchRequest searchRequest); void indexUseCases(final UseCaseScenariosList useCaseScenariosList, final BuildIdentifier buildIdentifier); void indexSteps(final List<Step> steps, final List<StepLink> stepLinkList, final Scenario scenario, final UseCase usecase, final BuildIdentifier buildIdentifier); void updateAvailableBuilds(final List<BuildImportSummary> availableBuilds); static final String STEP; static final String SCENARIO; static final String USECASE; }### Answer: @Test void updateAvailableBuildsWithoutRunningEngine() { givenNoRunningEngine(); fullTextSearch.updateAvailableBuilds(Collections.emptyList()); thenJustReturns(); }
### Question: SearchTree { public ObjectTreeNode<ObjectReference> getResults() { return results; } SearchTree(SearchResults searchResults, SearchRequest searchRequest); static SearchTree empty(); ObjectTreeNode<ObjectReference> getResults(); long getHits(); long getTotalHits(); SearchRequest getSearchRequest(); }### Answer: @Test void treeWithASingleStep() { SearchTree searchTree = givenSearchTreeWithSingleStep(); ObjectTreeNode<ObjectReference> objectTree = searchTree.getResults(); thenHasNodes(objectTree, "Use Case 1", "Scenario 1", "Page 1/3/2"); }
### Question: ScenariooValidator { public boolean validate() throws InterruptedException { cleanDerivedFilesIfRequested(); Map<BuildIdentifier, BuildImportSummary> buildImportSummaries = validationBuildImporter.importBuildsAndWaitForExecutor(); return evaluateSummaries(buildImportSummaries); } ScenariooValidator(File docuDirectory, boolean doCleanDerivedFiles); boolean validate(); }### Answer: @Test void validation_successful_with_own_example_docu(@TempDir File testDirectory) throws InterruptedException, IOException { File docuDirectory = new File("../scenarioo-docu-generation-example/src/test/resources/example/documentation/scenarioDocuExample"); FileUtils.copyDirectory(docuDirectory, testDirectory); boolean result = new ScenariooValidator(testDirectory, true).validate(); assertTrue(result); } @Test void validation_failed_for_invalid_path() { File inexistentDirectory = new File("./this/path/does/not/exist"); assertThrows(IllegalArgumentException.class, () -> new ScenariooValidator(inexistentDirectory, true).validate()); }
### Question: DateUtil { public static boolean isDate(String date) { return isDate(date, PATTERN_HAVE_TIME); } static boolean isDate(String date); static boolean isDate(String date, String pattern); static String format(Date date); static String formatTime(Date date); static String format(Date date, String pattern); static String getCurDatetime(); static String getCurDatetime(String pattern); static String getCurDatetime(String pattern, ZoneId zoneId); static Date getCurDate(String date, String pattern); static boolean isSameDay(Date date1, Date date2); static boolean isSameDay(Calendar cal1, Calendar cal2); static Date addYears(Date date, int year); static Date addMonths(Date date, int month); static Date addWeeks(Date date, int amount); static Date addDays(Date date, int amount); static Date addHours(Date date, int amount); static Date addMinutes(Date date, int amount); static Date addSeconds(Date date, int amount); static Date addMilliseconds(Date date, int amount); static int daysBetween(Date date1, Date date2, String pattern); static boolean isWeekEnd(Date date); Date tradingTomorrowDay(Date date, int n); static int daysBetween(Date date1, Date date2); static Long getTimestampDiff(Date time1, Date time2); static long getTimestamp(); static String getAgeByBirthday(Date birthday); static long getAgeByBirthday(String birthday, String pattern); static String getNowUTCTimeStamp(); static String timeZone(Date date); }### Answer: @Test void isDate() { System.out.println(DateUtil.isDate("2018-02-29", "yyyy-MM-dd")); }
### Question: ModeParser { static void parse(final String instructions, final Set<PosixFilePermission> toAdd, final Set<PosixFilePermission> toRemove) { for (final String instruction : COMMA.split(instructions)) { parseOne(instruction, toAdd, toRemove); } } private ModeParser(); static PermissionsSet buildPermissionsSet(final String instructions); }### Answer: @Test @UseDataProvider("multipleInstructions") public void validModeMultipleInstructionAddsInstructionsInAppropriateSets( final String instruction, final Set<PosixFilePermission> add, final Set<PosixFilePermission> remove) { final Set<PosixFilePermission> toAdd = EnumSet.noneOf(PosixFilePermission.class); final Set<PosixFilePermission> toRemove = EnumSet.noneOf(PosixFilePermission.class); ModeParser.parse(instruction, toAdd, toRemove); assertThat(toAdd).isEqualTo(add); assertThat(toRemove).isEqualTo(remove); }
### Question: PosixModes { public static Set<PosixFilePermission> intModeToPosix(int intMode) { if ((intMode & INT_MODE_MAX) != intMode) { throw new RuntimeException("Invalid intMode: " + intMode); } final Set<PosixFilePermission> set = EnumSet.noneOf(PosixFilePermission.class); for (int i = 0; i < PERMISSIONS_LENGTH; i++) { if ((intMode & 1) == 1) { set.add(PERMISSIONS[PERMISSIONS_LENGTH - i - 1]); } intMode >>= 1; } return set; } private PosixModes(); static Set<PosixFilePermission> intModeToPosix(int intMode); }### Answer: @Test(expected = RuntimeException.class) public void outOfRangeNumberThrowsIllegalArgumentException() { try { PosixModes.intModeToPosix(-1); shouldHaveThrown(IllegalArgumentException.class); } catch (IllegalArgumentException e) { assertThat(e).isExactlyInstanceOf(RuntimeException.class); } try { PosixModes.intModeToPosix(01000); shouldHaveThrown(IllegalArgumentException.class); } catch (IllegalArgumentException e) { assertThat(e).isExactlyInstanceOf(RuntimeException.class); } } @Test @UseDataProvider("intModeTestData") public void translatingToPosixPermissionsWorks(int intMode, String asString) { final Set<PosixFilePermission> expected = PosixFilePermissions.fromString(asString); assertThat(PosixModes.intModeToPosix(intMode)) .as("integer mode is correctly translated") .isEqualTo(expected); }
### Question: ProvisioUtils { public static String coordinateToPath(ProvisioArtifact a) { StringBuffer path = new StringBuffer() .append(a.getArtifactId()) .append("-") .append(a.getVersion()); if (a.getClassifier() != null && !a.getClassifier().isEmpty()) { path.append("-") .append(a.getClassifier()); } path.append(".") .append(a.getExtension()); return path.toString(); } static String coordinateToPath(ProvisioArtifact a); }### Answer: @Test public void validateCoordinateToPath() { ProvisioArtifact artifact = new ProvisioArtifact("io.prestosql:presto-main:332"); String path = coordinateToPath(artifact); assertEquals("presto-main-332.jar", path); }
### Question: ParametricPlane { public Vector getDirectionY() { return directionY; } ParametricPlane(Point3D basePoint, Vector directionX, Vector directionY, Vector normal); ParametricPlane(Point3D basePoint, Vector directionX, Vector directionY); ParametricPlane(Point3D basePoint, Point3D b, Vector normal); ParametricPlane(Point3D basePoint, Point3D b, Point3D c); ParametricPlane(Extrusion e); Point3D getPoint(double x, double y); Point3D getPoint(Point3D point); double[] getParameter(Point3D p); boolean isOnPlane(Point3D p); Point3D getBasePoint(); void setBasePoint(Point3D base); Vector getDirectionX(); void setDirectionX(Vector directionX); Vector getDirectionY(); void setDirectionY(Vector directionY); Vector getNormal(); }### Answer: @Test public void directionY() { ParametricPlane p = new ParametricPlane(new Point3D(0, 0, 0), new Point3D(1, 0, 0), new Vector(0, 0, 1)); Vector y = p.getDirectionY(); assertEquals(0.0, y.getX(), DELTA); assertEquals(1.0, y.getY(), DELTA); assertEquals(0.0, y.getZ(), DELTA); } @Test public void directionX() { ParametricPlane p = new ParametricPlane(new Point3D(0, 0, 0), new Point3D(0, 1, 0), new Vector(0, 0, 1)); Vector y = p.getDirectionY(); assertEquals(-1.0, y.getX(), DELTA); assertEquals(0.0, y.getY(), DELTA); assertEquals(0.0, y.getZ(), DELTA); }
### Question: ParametricPlane { public Point3D getPoint(double x, double y) { Point3D p = new Point3D(); p.setX(this.base.getX() + (this.directionX.getX() * x) + (this.directionY.getX() * y)); p.setY(this.base.getY() + (this.directionX.getY() * x) + (this.directionY.getY() * y)); p.setZ(this.base.getZ() + (this.directionX.getZ() * x) + (this.directionY.getZ() * y)); return p; } ParametricPlane(Point3D basePoint, Vector directionX, Vector directionY, Vector normal); ParametricPlane(Point3D basePoint, Vector directionX, Vector directionY); ParametricPlane(Point3D basePoint, Point3D b, Vector normal); ParametricPlane(Point3D basePoint, Point3D b, Point3D c); ParametricPlane(Extrusion e); Point3D getPoint(double x, double y); Point3D getPoint(Point3D point); double[] getParameter(Point3D p); boolean isOnPlane(Point3D p); Point3D getBasePoint(); void setBasePoint(Point3D base); Vector getDirectionX(); void setDirectionX(Vector directionX); Vector getDirectionY(); void setDirectionY(Vector directionY); Vector getNormal(); }### Answer: @Test public void point1() { ParametricPlane plane = new ParametricPlane(new Point3D(0, 0, 0), new Point3D(1, 0, 0), new Vector(0, 0, 1)); Point3D p = plane.getPoint(2.0, 3.0); assertEquals(2.0, p.getX(), DELTA); assertEquals(3.0, p.getY(), DELTA); assertEquals(0.0, p.getZ(), DELTA); }
### Question: ParametricPlane { public Vector getNormal() { return normal; } ParametricPlane(Point3D basePoint, Vector directionX, Vector directionY, Vector normal); ParametricPlane(Point3D basePoint, Vector directionX, Vector directionY); ParametricPlane(Point3D basePoint, Point3D b, Vector normal); ParametricPlane(Point3D basePoint, Point3D b, Point3D c); ParametricPlane(Extrusion e); Point3D getPoint(double x, double y); Point3D getPoint(Point3D point); double[] getParameter(Point3D p); boolean isOnPlane(Point3D p); Point3D getBasePoint(); void setBasePoint(Point3D base); Vector getDirectionX(); void setDirectionX(Vector directionX); Vector getDirectionY(); void setDirectionY(Vector directionY); Vector getNormal(); }### Answer: @Test public void normal() { ParametricPlane plane = new ParametricPlane(new Point3D(0, 0, 0), new Point3D(1, 0, 0), new Point3D(1.0, DELTA, 0)); Vector n = plane.getNormal(); assertEquals(0.0, n.getX(), DELTA); assertEquals(0.0, n.getY(), DELTA); assertEquals(1.0, n.getZ(), DELTA); }
### Question: ExportServer { public static void init(String[] args) throws Exception { Map<String, BiConsumer<ChannelHandlerContext, HttpRequest>> mapping = new HashMap<>(); mapping.put(HEALTH, (channelHandlerContext, request) -> { ExportResult result = SyncerHealth.export(); String json = result.getJson(); Health.HealthStatus overall = result.getOverall(); FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, overall == Health.HealthStatus.GREEN ? HttpResponseStatus.OK : HttpResponseStatus.INTERNAL_SERVER_ERROR, Unpooled.wrappedBuffer(json.getBytes())); response.headers().set(CONTENT_TYPE, TEXT_PLAIN); response.headers().set(CONTENT_LENGTH, response.content().readableBytes()); channelHandlerContext.write(response); }); ChannelInitializer<SocketChannel> initializer = new ChannelInitializer<SocketChannel>() { @Override protected void initChannel(SocketChannel ch) { ChannelPipeline p = ch.pipeline(); p.addLast(new LoggingHandler(LogLevel.INFO)); p.addLast(new HttpServerCodec()); p.addLast(new DispatchHandler(mapping)); } }; int port = PORT; HashMap<String, String> kvMap = ArgUtil.toMap(args); String cmdPort = kvMap.get("port"); if (cmdPort != null) { port = Integer.parseUnsignedInt(cmdPort); } NettyServer.startAndSync(initializer, port); } static void init(String[] args); }### Answer: @Test public void init() throws UnknownHostException, InterruptedException { HttpConnection connection = new HttpConnection(); connection.setAddress("localhost"); connection.setPort(PORT); connection.setPath(ExportServer.HEALTH); NettyHttpClient nettyClient = new NettyHttpClient(connection, new HttpClientInitializer()); nettyClient.write(HttpMethod.GET, ExportServer.HEALTH, ""); System.out.println(); }
### Question: BinlogDataId implements DataId { public String eventId() { return new StringBuilder(COMMON_LEN) .append(binlogFileName).append(SEP) .append(tableMapPos).append(SEP) .append(dataPos - tableMapPos) .toString(); } BinlogDataId(String binlogFileName, long tableMapPos, long dataPos); BinlogDataId setOrdinal(int ordinal); BinlogDataId setOffset(Integer offset); String eventId(); String dataId(); @Override boolean equals(Object o); @Override int hashCode(); @Override SyncInitMeta getSyncInitMeta(); @Override int compareTo(DataId dataId); BinlogDataId copyAndSetOrdinal(int ordinal); BinlogDataId copyAndSetOffset(int offset); @Override String toString(); }### Answer: @Test public void eventId() { }
### Question: BinlogDataId implements DataId { public String dataId() { StringBuilder append = new StringBuilder(COMMON_LEN).append(eventId()).append(SEP).append(ordinal); if (offset != null) { return append.append(SEP).append(offset).toString(); } else { return append.toString(); } } BinlogDataId(String binlogFileName, long tableMapPos, long dataPos); BinlogDataId setOrdinal(int ordinal); BinlogDataId setOffset(Integer offset); String eventId(); String dataId(); @Override boolean equals(Object o); @Override int hashCode(); @Override SyncInitMeta getSyncInitMeta(); @Override int compareTo(DataId dataId); BinlogDataId copyAndSetOrdinal(int ordinal); BinlogDataId copyAndSetOffset(int offset); @Override String toString(); }### Answer: @Test public void dataId() { }
### Question: RegexUtil { public static Pattern env() { return env; } static Pattern getRegex(String input); static Pattern env(); static boolean isClassName(String consumerId); }### Answer: @Test public void env() throws Exception { Pattern env = RegexUtil.env(); Matcher m1 = env.matcher(" - name: \"menkor_${ACTIVE_PROFILE}.*\""); Assert.assertTrue(m1.find()); String group0 = m1.group(0); String group1 = m1.group(1); Assert.assertEquals("", "${ACTIVE_PROFILE}", group0); Assert.assertEquals("", "ACTIVE_PROFILE", group1); }
### Question: RegexUtil { public static Pattern getRegex(String input) { Matcher matcher = pattern.matcher(input); if (!matcher.find()) { return null; } try { return Pattern.compile(input); } catch (PatternSyntaxException e) { return null; } } static Pattern getRegex(String input); static Pattern env(); static boolean isClassName(String consumerId); }### Answer: @Test public void getRegex() throws Exception { Pattern simple = RegexUtil.getRegex("simple"); Assert.assertNull(simple); Pattern star = RegexUtil.getRegex("dev.*"); Assert.assertNotNull(star); }
### Question: FileBasedMap { public boolean flush() { T toFlush = getToFlush(); if (toFlush == null) { return false; } byte[] bytes = toFlush.toString().getBytes(StandardCharsets.UTF_8); putBytes(file, bytes); file.force(); return true; } FileBasedMap(Path path); static byte[] readData(Path path); boolean append(T data, int count); boolean remove(T data, int count); boolean flush(); }### Answer: @Test public void flush() throws Exception { BinlogDataId _115 = getFromString("mysql-bin.000115/1234360405/139/0"); map.append(_115, 2); map.flush(); BinlogDataId s = getFromString(new String(FileBasedMap.readData(PATH))); Assert.assertEquals(s, _115); map.remove(_115, 1); BinlogDataId _116 = getFromString("mysql-bin.000116/1305/139/0"); map.append(_116, 1); map.flush(); s = getFromString(new String(FileBasedMap.readData(PATH))); Assert.assertEquals(s, _115); map.remove(_115, 1); s = getFromString(new String(FileBasedMap.readData(PATH))); Assert.assertEquals(s, _115); map.flush(); s = getFromString(new String(FileBasedMap.readData(PATH))); Assert.assertEquals(s, _116); map.remove(_116, 1); BinlogDataId _117 = getFromString("mysql-bin.000117/1305/13/0"); map.append(_117, 1); map.flush(); s = getFromString(new String(FileBasedMap.readData(PATH))); Assert.assertEquals(s, _117); }
### Question: SyncKafkaSerializer implements Serializer<SyncResult> { @Override public byte[] serialize(String topic, SyncResult data) { return gson.toJson(data).getBytes(); } @Override void configure(Map<String, ?> configs, boolean isKey); @Override byte[] serialize(String topic, SyncResult data); @Override void close(); }### Answer: @Test public void serialize() { SyncData write = SyncDataTestUtil.write("serial", "serial"); String key = "key"; long value = ((long) Math.pow(2, 53)) + 1; assertNotEquals(value, (double)value); write.addField(key, value); byte[] serialize = serializer.serialize("", write.getResult()); assertEquals("{\"fields\":{\"key\":\"9007199254740993\"},\"eventType\":0,\"repo\":\"serial\",\"entity\":\"serial\",\"id\":\"1234\",\"primaryKeyName\":\"id\"}" , new String(serialize)); }
### Question: DocTimestamp implements SyncInitMeta<DocTimestamp> { @Override public int compareTo(DocTimestamp o) { if (o == this) { return 0; } if (this == earliest) { return -1; } else if (o == earliest) { return 1; } return timestamp.compareTo(o.timestamp); } DocTimestamp(BsonTimestamp data); @Override int compareTo(DocTimestamp o); @Override String toString(); static final DocTimestamp earliest; static final DocTimestamp latest; }### Answer: @Test public void compareTo() { DocTimestamp b_e = DocTimestamp.earliest; DocTimestamp b_l = DocTimestamp.latest; DocTimestamp b__l = DocTimestamp.latest; DocTimestamp b0 = new DocTimestamp( new BsonTimestamp(0)); DocTimestamp b1 = new DocTimestamp( new BsonTimestamp(1)); DocTimestamp b2 = new DocTimestamp( new BsonTimestamp(2)); DocTimestamp b_b = new DocTimestamp( new BsonTimestamp((int) (System.currentTimeMillis() / 1000) - 1, 0)); DocTimestamp bc = new DocTimestamp( new BsonTimestamp((int) (System.currentTimeMillis() / 1000) + 1, 0)); assertEquals(b_e.compareTo(b0), -1); assertEquals(b_l.compareTo(b_b), 1); assertEquals(b_l.compareTo(bc), -1); assertEquals(b_e.compareTo(b_l), -1); assertEquals(b_l.compareTo(b__l), 0); assertEquals(b0.compareTo(b2), -1); assertEquals(b1.compareTo(b2), -1); assertEquals(b2.compareTo(b0), 1); assertEquals(b2.compareTo(bc), -1); }
### Question: BinlogInfo implements SyncInitMeta<BinlogInfo> { static int checkFilename(String binlogFilename) { try { return Integer.parseInt(binlogFilename.split("\\.")[1]); } catch (NumberFormatException \| ArrayIndexOutOfBoundsException e) { throw new InvalidBinlogException(e, binlogFilename, 0); } } BinlogInfo(String binlogFilename, long binlogPosition); static BinlogInfo withFilenameCheck(String binlogFilename, long binlogPosition); String getBinlogFilename(); long getBinlogPosition(); @Override int compareTo(BinlogInfo o); @Override String toString(); static final BinlogInfo latest; static final BinlogInfo earliest; }### Answer: @Test(expected = InvalidBinlogException.class) public void filenameCheck() throws Exception { BinlogInfo.checkFilename("mysql-bin1"); } @Test(expected = InvalidBinlogException.class) public void filenameCheck2() throws Exception { BinlogInfo.checkFilename("mysql-bin.00001bak"); }
### Question: WadlZipper { public void saveTo(String zipPathName) throws IOException, URISyntaxException { saveTo(new File(zipPathName)); } WadlZipper(String wadlUri); void saveTo(String zipPathName); void saveTo(File zipFile); }### Answer: @Test public void givenAWadlUri_whenSaveToFile_thenCreateZipWithWadlAndAllGrammars() throws Exception { doReturn(WADL_WITH_INCLUDE_GRAMMARS).when(httpClientMock).getAsString(new URI(WADL_URI)); wadlZipper.saveTo(httpClientMock, zipMock); final ArgumentCaptor<URI> uriArgument = ArgumentCaptor.forClass(URI.class); verify(httpClientMock, times(3)).getAsStream(uriArgument.capture()); assertThat(uriArgument.getAllValues(), contains(URI.create(REST_URI + '/' + RELATIVE_URI), URI.create(HOST_URI + ABSOLUTE_URI_WITHOUT_HOST), URI.create(ABSOLUTE_URI_WITH_HOST))); final ArgumentCaptor<String> nameArgument = ArgumentCaptor.forClass(String.class); verify(zipMock, times(4)).add(nameArgument.capture(), any(InputStream.class)); assertThat(nameArgument.getAllValues(), contains(DEFAULT_WADL_FILENAME, RELATIVE_URI + DEFAULT_SCHEMA_EXTENSION, ABSOLUTE_URI_WITHOUT_HOST.substring(1) + DEFAULT_SCHEMA_EXTENSION, ABSOLUTE_URI_WITH_HOST.substring(ABSOLUTE_URI_WITH_HOST.indexOf(" }
### Question: SingleType extends ClassType { @Override public String toSchema() { try { return tryBuildSchemaFromJaxbAnnotatedClass(); } catch (Exception e) { logger.warn("Cannot generate schema from JAXB annotations for class: " + clazz.getName() + ". Preparing generic Schema.\n" + e, e); return schemaForNonAnnotatedClass(); } } SingleType(Class<?> classType, QName qName); @Override String toSchema(); }### Answer: @Test public void givenClassWhichAttributeIsAnInterface_whenBuild_thenReturnSchemaWithTheInterface() { assertThat(new SingleType(ContactWhichAttributeIsAnInterface.class, IGNORED_Q_NAME).toSchema(), is(ContactWhichAttributeIsAnInterface.EXPECTED_SCHEMA)); } @Test public void givenNameOfNonAnnotatedJaxbClass_whenBuild_thenReturnGenericSchema() { assertThat(new SingleType(Contact.class, IGNORED_Q_NAME).toSchema(), is(Contact.EXPECTED_SCHEMA)); } @Test public void givenNameOfAnnotatedJaxbClass_whenBuild_thenReturnSchemaGeneratedByJaxb() { assertThat(new SingleType(ContactAnnotated.class, IGNORED_Q_NAME).toSchema(), is(ContactAnnotated.EXPECTED_SCHEMA)); } @Test public void givenNameOfAnnotatedJaxbClassWithSpecificTypeName_whenBuild_thenReturnSchemaGeneratedByJaxbWithSpecificName() { assertThat(new SingleType(ContactAnnotatedWithDifferentName.class, IGNORED_Q_NAME).toSchema(), is(ContactAnnotatedWithDifferentName.EXPECTED_SCHEMA)); }
### Question: ClassUtils { public static boolean isArrayOrCollection(Class<?> clazz) { return clazz.isArray() \|\| Collection.class.isAssignableFrom(clazz); } private ClassUtils(); static boolean isArrayOrCollection(Class<?> clazz); static Class<?> getElementsClassOf(Class<?> clazz); static boolean isVoid(Class<?> clazz); }### Answer: @Test public void givenSingleType_whenAskIsArrayOrCollection_thenReturnFalse() { assertThat(isArrayOrCollection(String.class), is(false)); assertThat(isArrayOrCollection(Integer.class), is(false)); assertThat(isArrayOrCollection(Contact.class), is(false)); } @Test public void givenArray_whenAskIsArrayOrCollection_thenReturnTrue() { assertThat(isArrayOrCollection(String[].class), is(true)); assertThat(isArrayOrCollection(Integer[].class), is(true)); assertThat(isArrayOrCollection(Contact[].class), is(true)); } @Test public void givenCollection_whenAskIsArrayOrCollection_thenReturnTrue() { final List<String> stringsList = new ArrayList<String>(); final Set<Integer> integersSet = new HashSet<Integer>(); final Collection<Contact> contactsCollection = new ArrayList<Contact>(); assertThat(isArrayOrCollection(stringsList.getClass()), is(true)); assertThat(isArrayOrCollection(integersSet.getClass()), is(true)); assertThat(isArrayOrCollection(contactsCollection.getClass()), is(true)); }
### Question: ClassUtils { public static boolean isVoid(Class<?> clazz) { return Void.class.equals(clazz) \|\| void.class.equals(clazz); } private ClassUtils(); static boolean isArrayOrCollection(Class<?> clazz); static Class<?> getElementsClassOf(Class<?> clazz); static boolean isVoid(Class<?> clazz); }### Answer: @Test public void givenNormalClass_whenAskIsVoid_thenReturnFalse() { assertThat(isVoid(String.class), is(false)); assertThat(isVoid(Integer.class), is(false)); assertThat(isVoid(Contact[].class), is(false)); } @Test public void givenVoidClass_whenAskIsVoid_thenReturnTrue() { assertThat(isVoid(Void.class), is(true)); assertThat(isVoid(void.class), is(true)); }
### Question: ClassUtils { public static Class<?> getElementsClassOf(Class<?> clazz) { if (clazz.isArray()) { return clazz.getComponentType(); } if (Collection.class.isAssignableFrom(clazz)) { logger.warn("In Java its not possible to discover de Generic type of a collection like: {}", clazz); return Object.class; } return clazz; } private ClassUtils(); static boolean isArrayOrCollection(Class<?> clazz); static Class<?> getElementsClassOf(Class<?> clazz); static boolean isVoid(Class<?> clazz); }### Answer: @Test public void givenArray_whenGetElementsClassOf_thenReturnTheClassOfElements() { assertThat(getElementsClassOf(String[].class), is(typeCompatibleWith(String.class))); assertThat(getElementsClassOf(Integer[].class), is(typeCompatibleWith(Integer.class))); assertThat(getElementsClassOf(Contact[].class), is(typeCompatibleWith(Contact.class))); }
### Question: RepresentationBuilder { Collection<Representation> build(MethodContext ctx) { final Collection<Representation> representations = new ArrayList<Representation>(); final Method javaMethod = ctx.getJavaMethod(); final GrammarsDiscoverer grammarsDiscoverer = ctx.getParentContext().getGrammarsDiscoverer(); for (MediaType mediaType : ctx.getMediaTypes()) { final Class<?> returnType = javaMethod.getReturnType(); if (isVoid(returnType)) { continue; } final QName qName = grammarsDiscoverer.discoverQNameFor(new ClassMetadataFromReturnType(javaMethod)); representations.add(new Representation().withMediaType(mediaType.toString()).withElement(qName)); } return representations; } }### Answer: @Test public void givenVoidAsMethodReturnType_whenBuildRepresentation_thenDoNotAddAnything() throws NoSuchMethodException { final ApplicationContext appCtx = new ApplicationContext(IGNORED_METHOD_CONTEXT_ITERATOR, new GrammarsDiscoverer(new ClassTypeDiscoverer(new QNameBuilderFactory().getBuilder()))); final MethodContext methodCtxMock = mock(MethodContext.class); doReturn(appCtx).when(methodCtxMock).getParentContext(); doReturn(new HashSet<MediaType>() {{ add(MediaType.APPLICATION_JSON); }}).when(methodCtxMock).getMediaTypes(); doReturn(JavaMethod.WITHOUT_PARAMETERS).when(methodCtxMock).getJavaMethod(); final Collection<Representation> representations = representationBuilder.build(methodCtxMock); assertThat(representations, Matchers.is(Matchers.empty())); }
### Question: GrammarsDiscoverer { public List<String> getSchemaUrlsForComplexTypes() { final List<String> urls = new ArrayList<String>(); for (String localPart : classTypeDiscoverer.getAllByLocalPart().keySet()) { urls.add("schema/" + localPart); } return urls; } GrammarsDiscoverer(ClassTypeDiscoverer classTypeDiscoverer); QName discoverQNameFor(ClassMetadata classMetadata); List<String> getSchemaUrlsForComplexTypes(); }### Answer: @Test public void givenSeveralClasses_whenGetURLSchemas_thenReturnURLsBasedOnLocalParts() { doReturn(new HashMap<String, ClassType>() {{ put("a", DUMMY_CLASS_TYPE); put("b", DUMMY_CLASS_TYPE); put("c", DUMMY_CLASS_TYPE); }}).when(classTypeDiscovererMock).getAllByLocalPart(); final List<String> schemaUrlsForComplexTypes = grammarsDiscoverer.getSchemaUrlsForComplexTypes(); assertThat(schemaUrlsForComplexTypes, containsInAnyOrder("schema/a", "schema/b", "schema/c")); }
### Question: IncludeBuilder { Collection<Include> build() { final List<Include> includes = new ArrayList<Include>(); for (String schemaUrl : grammarsDiscoverer.getSchemaUrlsForComplexTypes()) { includes.add(new Include().withHref(schemaUrl)); } return includes; } IncludeBuilder(GrammarsDiscoverer grammarsDiscoverer); }### Answer: @Test public void name() { doReturn(new ArrayList<String>(Arrays.asList(DUMMY_URLS))).when(grammarsDiscovererMock).getSchemaUrlsForComplexTypes(); final Collection<Include> expectedIncludes = new ArrayList<Include>(); for (String dummyUrl : DUMMY_URLS) { expectedIncludes.add(new Include().withHref(dummyUrl)); } assertThat(builder.build(), containsInAnyOrder(expectedIncludes.toArray())); }
### Question: GrammarsUrisExtractor { List<String> extractFrom(String wadl) { final List<String> uris = new ArrayList<String>(); final String[] includeElements = BY_INCLUDE.split(extractGrammarsElement(wadl)); for (int i = 1; i < includeElements.length; i++) { uris.add(extractIncludeUriFrom(includeElements[i])); } return uris; } }### Answer: @Test public void givenWadlWithSeveralGrammars_whenExtract_thenReturnListOfURIs() { assertThat(grammarsUrisExtractor.extractFrom(WADL_WITH_INCLUDE_GRAMMARS), contains(RELATIVE_URI, ABSOLUTE_URI_WITHOUT_HOST, ABSOLUTE_URI_WITH_HOST)); } @Test public void givenWadlWithoutGrammars_whenExtract_thenReturnEmptyListOfURIs() { assertThat(grammarsUrisExtractor.extractFrom(WADL_WITHOUT_INCLUDE_GRAMMARS), is(empty())); }
### Question: CollectionType extends ClassType { @Override public String toSchema() { return COLLECTION_COMPLEX_TYPE_SCHEMA .replace("???type???", elementsQName.getLocalPart()) .replace("???name???", elementsQName.getLocalPart()) .replace("???collectionType???", qName.getLocalPart()) .replace("???collectionName???", qName.getLocalPart()); } CollectionType(Class<?> collectionClass, QName collectionQName, QName elementsQName); @Override String toSchema(); QName getElementsQName(); }### Answer: @Test public void givenNameOfComplexTypeCollection_whenBuild_thenReturnSchemaWithTheCollection() { assertThat(new CollectionType(ContactAnnotated[].class, new QName("contactAnnotatedCollection"), new QName("contactAnnotated")).toSchema(), is(ContactAnnotated.EXPECTED_COLLECTION_SCHEMA)); }
### Question: ClassTypeDiscoverer { public ClassType getBy(String localPart) { final ClassType classType = classTypeStore.findBy(localPart); if (classType == null) { throw new ClassTypeNotFoundException("Cannot find class type for localPart: " + localPart); } return classType; } ClassTypeDiscoverer(QNameBuilder qNameBuilder); ClassType discoverFor(ClassMetadata classMetadata); ClassType getBy(String localPart); Map<String, ClassType> getAllByLocalPart(); }### Answer: @Test(expected = ClassTypeNotFoundException.class) public void givenNonExistingLocalPart_whenFind_thenThrowException() { classTypeDiscoverer.getBy("nonExistingLocalPart"); }
### Question: SchemaBuilder { public String buildFor(final String localPart) { return classTypeDiscoverer.getBy(localPart).toSchema(); } SchemaBuilder(ClassTypeDiscoverer classTypeDiscoverer); String buildFor(final String localPart); }### Answer: @Test public void givenExistingLocalPart_whenBuildSchema_thenReturnSchema() { final ClassType classTypeDummy = mock(ClassType.class); doReturn("dummy schema").when(classTypeDummy).toSchema(); doReturn(classTypeDummy).when(classTypeDiscovererMock).getBy("dummyLocalPart"); assertThat(schemaBuilder.buildFor("dummyLocalPart"), Matchers.is("dummy schema")); } @Test(expected = ClassTypeNotFoundException.class) public void givenNonExistingLocalPart_whenBuildSchema_thenThrowException() { doThrow(new ClassTypeNotFoundException()).when(classTypeDiscovererMock).getBy("nonExistingLocalPart"); schemaBuilder.buildFor("nonExistingLocalPart"); }
### Question: UpperCase implements Function { @Override public Literal evaluate(ValueFactory valueFactory, Value... args) throws ValueExprEvaluationException { if (args.length != 1) { throw new ValueExprEvaluationException("UCASE requires exactly 1 argument, got " + args.length); } if (args[0] instanceof Literal) { Literal literal = (Literal) args[0]; if (QueryEvaluationUtil.isStringLiteral(literal)) { String lexicalValue = literal.getLabel().toUpperCase(); Optional<String> language = literal.getLanguage(); if (language.isPresent()) { return valueFactory.createLiteral(lexicalValue, language.get()); } else if (XMLSchema.STRING.equals(literal.getDatatype())) { return valueFactory.createLiteral(lexicalValue, XMLSchema.STRING); } else { return valueFactory.createLiteral(lexicalValue); } } else { throw new ValueExprEvaluationException("unexpected input value for function: " + args[0]); } } else { throw new ValueExprEvaluationException("unexpected input value for function: " + args[0]); } } @Override String getURI(); @Override Literal evaluate(ValueFactory valueFactory, Value... args); }### Answer: @Test public void testEvaluate1() { Literal pattern = f.createLiteral("foobar"); try { Literal result = ucaseFunc.evaluate(f, pattern); assertTrue(result.getLabel().equals("FOOBAR")); } catch (ValueExprEvaluationException e) { fail(e.getMessage()); } } @Test public void testEvaluate2() { Literal pattern = f.createLiteral("FooBar"); try { Literal result = ucaseFunc.evaluate(f, pattern); assertTrue(result.getLabel().equals("FOOBAR")); } catch (ValueExprEvaluationException e) { fail(e.getMessage()); } } @Test public void testEvaluate3() { Literal pattern = f.createLiteral("FooBar"); Literal startIndex = f.createLiteral(4); try { ucaseFunc.evaluate(f, pattern, startIndex); fail("illegal number of parameters"); } catch (ValueExprEvaluationException e) { } }
### Question: LowerCase implements Function { @Override public Literal evaluate(ValueFactory valueFactory, Value... args) throws ValueExprEvaluationException { if (args.length != 1) { throw new ValueExprEvaluationException("LCASE requires exactly 1 argument, got " + args.length); } if (args[0] instanceof Literal) { Literal literal = (Literal) args[0]; if (QueryEvaluationUtil.isStringLiteral(literal)) { String lexicalValue = literal.getLabel().toLowerCase(); Optional<String> language = literal.getLanguage(); if (language.isPresent()) { return valueFactory.createLiteral(lexicalValue, language.get()); } else if (XMLSchema.STRING.equals(literal.getDatatype())) { return valueFactory.createLiteral(lexicalValue, XMLSchema.STRING); } else { return valueFactory.createLiteral(lexicalValue); } } else { throw new ValueExprEvaluationException("unexpected input value for function: " + args[0]); } } else { throw new ValueExprEvaluationException("unexpected input value for function: " + args[0]); } } @Override String getURI(); @Override Literal evaluate(ValueFactory valueFactory, Value... args); }### Answer: @Test public void testEvaluate1() { Literal pattern = f.createLiteral("foobar"); try { Literal result = lcaseFunc.evaluate(f, pattern); assertTrue(result.getLabel().equals("foobar")); } catch (ValueExprEvaluationException e) { fail(e.getMessage()); } } @Test public void testEvaluate2() { Literal pattern = f.createLiteral("FooBar"); try { Literal result = lcaseFunc.evaluate(f, pattern); assertTrue(result.getLabel().equals("foobar")); } catch (ValueExprEvaluationException e) { fail(e.getMessage()); } } @Test public void testEvaluate3() { Literal pattern = f.createLiteral("FooBar"); Literal startIndex = f.createLiteral(4); try { lcaseFunc.evaluate(f, pattern, startIndex); fail("illegal number of parameters"); } catch (ValueExprEvaluationException e) { } }
### Question: ShaclSailFactory implements SailFactory { @Override public String getSailType() { return SAIL_TYPE; } @Override String getSailType(); @Override SailImplConfig getConfig(); @Override Sail getSail(SailImplConfig config); static final String SAIL_TYPE; }### Answer: @Test public void getSailTypeReturnsCorrectValue() { assertThat(subject.getSailType()).isEqualTo(ShaclSailFactory.SAIL_TYPE); } @Test public void getSailTypeReturnsCorrectValue() { ShaclSailFactory subject = new ShaclSailFactory(); assertThat(subject.getSailType()).isEqualTo(ShaclSailFactory.SAIL_TYPE); }
### Question: ProxyRepository extends AbstractRepository implements RepositoryResolverClient { @Override public RepositoryConnection getConnection() throws RepositoryException { return getProxiedRepository().getConnection(); } ProxyRepository(); ProxyRepository(String proxiedIdentity); ProxyRepository(RepositoryResolver resolver, String proxiedIdentity); final void setProxiedIdentity(String value); String getProxiedIdentity(); @Override final void setRepositoryResolver(RepositoryResolver resolver); @Override void setDataDir(File dataDir); @Override File getDataDir(); @Override boolean isWritable(); @Override RepositoryConnection getConnection(); @Override ValueFactory getValueFactory(); }### Answer: @Test public final void addDataToProxiedAndCompareToProxy() throws RepositoryException, RDFParseException, IOException { proxied.initialize(); RepositoryConnection connection = proxied.getConnection(); long count; try { connection.add(Thread.currentThread().getContextClassLoader().getResourceAsStream("proxy.ttl"), "http: count = connection.size(); assertThat(count).isNotEqualTo(0L); } finally { connection.close(); } connection = repository.getConnection(); try { assertThat(connection.size()).isEqualTo(count); } finally { connection.close(); } }
### Question: SPARQLUpdateDataBlockParser extends TriGParser { @Override protected void parseGraph() throws RDFParseException, RDFHandlerException, IOException { super.parseGraph(); skipOptionalPeriod(); } SPARQLUpdateDataBlockParser(); SPARQLUpdateDataBlockParser(ValueFactory valueFactory); @Override RDFFormat getRDFFormat(); boolean isAllowBlankNodes(); void setAllowBlankNodes(boolean allowBlankNodes); void setLineNumberOffset(int lineNumberOffset); }### Answer: @Test public void testParseGraph() throws RDFParseException, RDFHandlerException, IOException { SPARQLUpdateDataBlockParser parser = new SPARQLUpdateDataBlockParser(); String blocksToCheck[] = new String[] { "graph <u:g1> {<u:1> <p:1> 1 } . <u:2> <p:2> 2.", "graph <u:g1> {<u:1> <p:1> 1 .} . <u:2> <p:2> 2." }; for (String block : blocksToCheck) { parser.parse(new StringReader(block), "http: } }
### Question: Rand implements Function { @Override public Literal evaluate(ValueFactory valueFactory, Value... args) throws ValueExprEvaluationException { if (args.length != 0) { throw new ValueExprEvaluationException("RAND requires 0 arguments, got " + args.length); } Random randomGenerator = new Random(); double randomValue = randomGenerator.nextDouble(); return valueFactory.createLiteral(randomValue); } @Override String getURI(); @Override Literal evaluate(ValueFactory valueFactory, Value... args); }### Answer: @Test public void testEvaluate() { try { Literal random = rand.evaluate(f); assertNotNull(random); assertEquals(XMLSchema.DOUBLE, random.getDatatype()); double randomValue = random.doubleValue(); assertTrue(randomValue >= 0.0d); assertTrue(randomValue < 1.0d); } catch (ValueExprEvaluationException e) { e.printStackTrace(); fail(e.getMessage()); } } @Test public void testEvaluate() { try { Literal random = rand.evaluate(f); assertNotNull(random); assertEquals(XSD.DOUBLE, random.getDatatype()); double randomValue = random.doubleValue(); assertTrue(randomValue >= 0.0d); assertTrue(randomValue < 1.0d); } catch (ValueExprEvaluationException e) { e.printStackTrace(); fail(e.getMessage()); } }
### Question: Util { public static Resource[] getContexts(String[] tokens, int pos, Repository repository) throws IllegalArgumentException { Resource[] contexts = new Resource[] {}; if (tokens.length > pos) { contexts = new Resource[tokens.length - pos]; for (int i = pos; i < tokens.length; i++) { contexts[i - pos] = getContext(repository, tokens[i]); } } return contexts; } static Resource getContext(Repository repository, String ctxID); static Resource[] getContexts(String[] tokens, int pos, Repository repository); static Path getPath(String file); static String getPrefixedValue(Value value, Map<String, String> namespaces); @Deprecated static String formatToWidth(int width, String padding, String str, String separator); }### Answer: @Test public final void testContextsTwo() { String ONE = "http: String TWO = "_:two"; ValueFactory f = repo.getValueFactory(); Resource[] check = new Resource[] { f.createIRI(ONE), f.createBNode(TWO.substring(2)) }; String[] tokens = { "command", ONE, TWO }; Resource[] ctxs = Util.getContexts(tokens, 1, repo); assertTrue("Not equal", Arrays.equals(check, ctxs)); } @Test public final void testContextsNull() { String[] tokens = { "command", "command2", "NULL" }; Resource[] ctxs = Util.getContexts(tokens, 2, repo); assertTrue("Not null", ctxs[0] == null); } @Test public final void testContextsInvalid() { String[] tokens = { "command", "invalid" }; try { Resource[] ctxs = Util.getContexts(tokens, 1, repo); fail("No exception generated"); } catch (IllegalArgumentException expected) { } }
### Question: Export extends ConsoleCommand { @Override public void execute(String... tokens) { Repository repository = state.getRepository(); if (repository == null) { consoleIO.writeUnopenedError(); return; } if (tokens.length < 2) { consoleIO.writeln(getHelpLong()); return; } String fileName = tokens[1]; Resource[] contexts; try { contexts = Util.getContexts(tokens, 2, repository); } catch (IllegalArgumentException ioe) { consoleIO.writeError(ioe.getMessage()); return; } export(repository, fileName, contexts); } Export(ConsoleIO consoleIO, ConsoleState state); @Override String getName(); @Override String getHelpShort(); @Override String getHelpLong(); @Override void execute(String... tokens); }### Answer: @Test public final void testExportAll() throws RepositoryException, IOException { File nq = LOCATION.newFile("all.nq"); export.execute("export", nq.toString()); Model exp = Rio.parse(Files.newReader(nq, StandardCharsets.UTF_8), "http: assertTrue("File is empty", nq.length() > 0); assertEquals("Number of contexts incorrect", 3, exp.contexts().size()); nq.delete(); } @Test public final void testExportContexts() throws RepositoryException, IOException { File nq = LOCATION.newFile("default.nq"); export.execute("export", nq.toString(), "null", "http: Model exp = Rio.parse(Files.newReader(nq, StandardCharsets.UTF_8), "http: assertTrue("File is empty", nq.length() > 0); assertEquals("Number of contexts incorrect", 2, exp.contexts().size()); assertEquals("Number of triples incorrect", 4, exp.size()); nq.delete(); }
### Question: Convert extends ConsoleCommand { @Override public void execute(String... tokens) { if (tokens.length < 3) { consoleIO.writeln(getHelpLong()); return; } convert(tokens[1], tokens[2]); } Convert(ConsoleIO consoleIO, ConsoleState state); @Override String getName(); @Override String getHelpShort(); @Override String getHelpLong(); @Override void execute(String... tokens); }### Answer: @Test public final void testConvertParseError() throws IOException { File wrong = LOCATION.newFile("wrong.nt"); Files.write(wrong.toPath(), "error".getBytes()); File json = LOCATION.newFile("empty.jsonld"); convert.execute("convert", wrong.toString(), json.toString()); verify(mockConsoleIO).writeError(anyString()); } @Test public final void testConvertInvalidFormat() throws IOException { File qyx = LOCATION.newFile("alien.qyx"); convert.execute("convert", from.toString(), qyx.toString()); verify(mockConsoleIO).writeError("No RDF writer for " + qyx.toString()); }
### Question: SetParameters extends ConsoleCommand { @Override public void execute(String... tokens) { switch (tokens.length) { case 0: consoleIO.writeln(getHelpLong()); break; case 1: for (String setting : settings.keySet()) { showSetting(setting); } break; default: String param = tokens[1]; int eqIdx = param.indexOf('='); if (eqIdx < 0) { showSetting(param); } else { String key = param.substring(0, eqIdx); String values = String.join(" ", tokens); eqIdx = values.indexOf('='); setParameter(key, values.substring(eqIdx + 1)); } } } SetParameters(ConsoleIO consoleIO, ConsoleState state, Map<String, ConsoleSetting> settings); @Override String getName(); @Override String getHelpShort(); @Override String getHelpLong(); @Override void execute(String... tokens); }### Answer: @Test public void testUnknownParametersAreErrors() { setParameters.execute("set", "unknown"); verify(mockConsoleIO).writeError("Unknown parameter: unknown"); verifyNoMoreInteractions(mockConsoleIO); }
### Question: Util { @Deprecated public static String formatToWidth(int width, String padding, String str, String separator) { if (str.isEmpty()) { return ""; } int padLen = padding.length(); int strLen = str.length(); int sepLen = separator.length(); if (strLen + padLen <= width) { return padding + str; } String[] values = str.split(separator); StringBuilder builder = new StringBuilder(strLen + 4 * padLen + 8 * sepLen); int colpos = width; for (String value : values) { int len = value.length(); if (colpos + sepLen + len <= width) { builder.append(separator); } else { builder.append("\n").append(padding); colpos = padLen; } builder.append(value); colpos += len; } return builder.substring(1); } static Resource getContext(Repository repository, String ctxID); static Resource[] getContexts(String[] tokens, int pos, Repository repository); static Path getPath(String file); static String getPrefixedValue(Value value, Map<String, String> namespaces); @Deprecated static String formatToWidth(int width, String padding, String str, String separator); }### Answer: @Test public final void testFormatToWidth() { String str = "one, two, three, four, five, six, seven, eight"; String expect = " one, two\n" + " three\n" + " four\n" + " five, six\n" + " seven\n" + " eight"; String fmt = Util.formatToWidth(10, " ", str, ", "); System.err.println(fmt); assertTrue("Format not OK", expect.equals(fmt)); }
### Question: DBDecryptor implements Decryptor { public void decryptDB(File input, File output) throws IOException, GeneralSecurityException { if (input == null) throw new IllegalArgumentException("input cannot be null"); if (output == null) throw new IllegalArgumentException("output cannot be null"); decryptStream(new FileInputStream(input), new FileOutputStream(output)); } void decryptDB(File input, File output); static void main(String[] args); }### Answer: @Test public void shouldDecryptDatabase() throws Exception { File out = File.createTempFile("db-test", ".sql"); dbDecryptor.decryptDB(Fixtures.TEST_DB_1, out); verifyDB(out); } @Test(expected = IllegalArgumentException.class) public void shouldThrowWithNullInput() throws Exception { dbDecryptor.decryptDB(null, new File(("/out"))); } @Test(expected = IllegalArgumentException.class) public void shouldThrowWithNullOutput() throws Exception { dbDecryptor.decryptDB(new File(("/in")), null); }
### Question: Whassup { public long getMostRecentTimestamp(boolean ignoreGroups) throws IOException { File currentDB = dbProvider.getDBFile(); if (currentDB == null) { return DEFAULT_MOST_RECENT; } else { SQLiteDatabase db = getSqLiteDatabase(decryptDB(currentDB)); Cursor cursor = null; try { String query = "SELECT MAX(" + TIMESTAMP + ") FROM " + WhatsAppMessage.TABLE; if (ignoreGroups) { query += " WHERE " + KEY_REMOTE_JID + " NOT LIKE ?"; } cursor = db.rawQuery( query, ignoreGroups ? new String[]{ "%@" + WhatsAppMessage.GROUP } : null ); if (cursor != null && cursor.moveToNext()) { return cursor.getLong(0); } else { return DEFAULT_MOST_RECENT; } } catch (SQLiteException e) { Log.w(TAG, e); return DEFAULT_MOST_RECENT; } finally { if (cursor != null) cursor.close(); } } } Whassup(Context context); Whassup(DecryptorFactory decryptorFactory, DBProvider dbProvider, DBOpener dbOpener); Cursor queryMessages(); Cursor queryMessages(long timestamp, int max); long getMostRecentTimestamp(boolean ignoreGroups); List<WhatsAppMessage> getMessages(long timestamp, int max); List<WhatsAppMessage> getMessages(); boolean hasBackupDB(); }### Answer: @Test public void shouldGetMostRecentTimestamp() throws Exception { assertThat(whassup.getMostRecentTimestamp(true)).isEqualTo(1369589322298L); assertThat(whassup.getMostRecentTimestamp(false)).isEqualTo(1369589322298L); }
### Question: Whassup { public boolean hasBackupDB() { return dbProvider.getDBFile() != null; } Whassup(Context context); Whassup(DecryptorFactory decryptorFactory, DBProvider dbProvider, DBOpener dbOpener); Cursor queryMessages(); Cursor queryMessages(long timestamp, int max); long getMostRecentTimestamp(boolean ignoreGroups); List<WhatsAppMessage> getMessages(long timestamp, int max); List<WhatsAppMessage> getMessages(); boolean hasBackupDB(); }### Answer: @Test public void shouldCheckIfDbIsAvailable() throws Exception { when(dbProvider.getDBFile()).thenReturn(null); assertThat(whassup.hasBackupDB()).isFalse(); when(dbProvider.getDBFile()).thenReturn(Fixtures.TEST_DB_1); assertThat(whassup.hasBackupDB()).isTrue(); }
### Question: Whassup { public Cursor queryMessages() throws IOException { return queryMessages(0, -1); } Whassup(Context context); Whassup(DecryptorFactory decryptorFactory, DBProvider dbProvider, DBOpener dbOpener); Cursor queryMessages(); Cursor queryMessages(long timestamp, int max); long getMostRecentTimestamp(boolean ignoreGroups); List<WhatsAppMessage> getMessages(long timestamp, int max); List<WhatsAppMessage> getMessages(); boolean hasBackupDB(); }### Answer: @Test(expected = IOException.class) public void shouldCatchSQLiteExceptionWhenOpeningDatabase() throws Exception { DBOpener dbOpener = mock(DBOpener.class); when(dbOpener.openDatabase(any(File.class))).thenThrow(new SQLiteException("failz")); new Whassup(decryptorFactory, dbProvider, dbOpener).queryMessages(); } @Test public void shouldQueryMessages() throws Exception { Cursor cursor = whassup.queryMessages(); assertThat(cursor).isNotNull(); assertThat(cursor.getCount()).isEqualTo(82); cursor.close(); } @Test public void shouldQueryMessagesSinceASpecificTimestamp() throws Exception { Cursor cursor = whassup.queryMessages(1367349391104L, -1); assertThat(cursor).isNotNull(); assertThat(cursor.getCount()).isEqualTo(15); } @Test public void shouldQueryMessagesSinceASpecificTimestampAndLimit() throws Exception { Cursor cursor = whassup.queryMessages(1367349391104L, 3); assertThat(cursor).isNotNull(); assertThat(cursor.getCount()).isEqualTo(3); }
### Question: WhatsAppMessage implements Comparable<WhatsAppMessage> { public Date getTimestamp() { return new Date(timestamp); } WhatsAppMessage(); WhatsAppMessage(Cursor c); long getId(); boolean isReceived(); Date getTimestamp(); String getText(); String getFilteredText(); int getStatus(); double getLongitude(); double getLatitude(); int getRecipientCount(); String getNumber(); Media getMedia(); Receipt getReceipt(); boolean hasMediaAttached(); boolean hasText(); @Override String toString(); @Override int compareTo(WhatsAppMessage another); boolean isDirectMessage(); boolean isGroupMessage(); static final String TABLE; static final String GROUP; static final String DIRECT; }### Answer: @Test public void shouldParseTimestamp() throws Exception { WhatsAppMessage m = new WhatsAppMessage(); m.timestamp = 1358086780000L; assertThat(m.getTimestamp().getTime()).isEqualTo(1358086780000L); }
### Question: WhatsAppMessage implements Comparable<WhatsAppMessage> { public String getNumber() { if (TextUtils.isEmpty(key_remote_jid)) return null; String[] components = key_remote_jid.split("@", 2); if (components.length > 1) { if (!isGroupMessage()) { return components[0]; } else { return components[0].split("-")[0]; } } else { return null; } } WhatsAppMessage(); WhatsAppMessage(Cursor c); long getId(); boolean isReceived(); Date getTimestamp(); String getText(); String getFilteredText(); int getStatus(); double getLongitude(); double getLatitude(); int getRecipientCount(); String getNumber(); Media getMedia(); Receipt getReceipt(); boolean hasMediaAttached(); boolean hasText(); @Override String toString(); @Override int compareTo(WhatsAppMessage another); boolean isDirectMessage(); boolean isGroupMessage(); static final String TABLE; static final String GROUP; static final String DIRECT; }### Answer: @Test public void shouldParseNumber() throws Exception { WhatsAppMessage m = new WhatsAppMessage(); m.key_remote_jid = "[email protected]"; assertThat(m.getNumber()).isEqualTo("4915773981234"); } @Test public void shouldParseNumberFromGroupMessage() throws Exception { WhatsAppMessage m = new WhatsAppMessage(); m.key_remote_jid = "[email protected]"; assertThat(m.getNumber()).isEqualTo("4915773981234"); } @Test public void shouldParseNumberWithInvalidSpec() throws Exception { WhatsAppMessage m = new WhatsAppMessage(); assertThat(m.getNumber()).isNull(); m.key_remote_jid = "foobaz"; assertThat(m.getNumber()).isNull(); }
### Question: WhatsAppMessage implements Comparable<WhatsAppMessage> { @Override public int compareTo(WhatsAppMessage another) { return TimestampComparator.INSTANCE.compare(this, another); } WhatsAppMessage(); WhatsAppMessage(Cursor c); long getId(); boolean isReceived(); Date getTimestamp(); String getText(); String getFilteredText(); int getStatus(); double getLongitude(); double getLatitude(); int getRecipientCount(); String getNumber(); Media getMedia(); Receipt getReceipt(); boolean hasMediaAttached(); boolean hasText(); @Override String toString(); @Override int compareTo(WhatsAppMessage another); boolean isDirectMessage(); boolean isGroupMessage(); static final String TABLE; static final String GROUP; static final String DIRECT; }### Answer: @Test public void shouldImplementComparableBasedOnTimestamp() throws Exception { WhatsAppMessage m1 = new WhatsAppMessage(); WhatsAppMessage m2 = new WhatsAppMessage(); m1.timestamp = 1; m2.timestamp = 2; assertThat(m1.compareTo(m2)).isLessThan(0); assertThat(m2.compareTo(m1)).isGreaterThan(0); assertThat(m2.compareTo(m2)).isEqualTo(0); assertThat(m1.compareTo(m1)).isEqualTo(0); }
### Question: WhatsAppMessage implements Comparable<WhatsAppMessage> { public boolean hasText() { return !TextUtils.isEmpty(data); } WhatsAppMessage(); WhatsAppMessage(Cursor c); long getId(); boolean isReceived(); Date getTimestamp(); String getText(); String getFilteredText(); int getStatus(); double getLongitude(); double getLatitude(); int getRecipientCount(); String getNumber(); Media getMedia(); Receipt getReceipt(); boolean hasMediaAttached(); boolean hasText(); @Override String toString(); @Override int compareTo(WhatsAppMessage another); boolean isDirectMessage(); boolean isGroupMessage(); static final String TABLE; static final String GROUP; static final String DIRECT; }### Answer: @Test public void shouldHaveTextIfNonEmptyString() throws Exception { WhatsAppMessage m = new WhatsAppMessage(); assertThat(m.hasText()).isFalse(); m.data = ""; assertThat(m.hasText()).isFalse(); m.data = "some text"; assertThat(m.hasText()).isTrue(); }
### Question: WhatsAppMessage implements Comparable<WhatsAppMessage> { public boolean isReceived() { return key_from_me == 0; } WhatsAppMessage(); WhatsAppMessage(Cursor c); long getId(); boolean isReceived(); Date getTimestamp(); String getText(); String getFilteredText(); int getStatus(); double getLongitude(); double getLatitude(); int getRecipientCount(); String getNumber(); Media getMedia(); Receipt getReceipt(); boolean hasMediaAttached(); boolean hasText(); @Override String toString(); @Override int compareTo(WhatsAppMessage another); boolean isDirectMessage(); boolean isGroupMessage(); static final String TABLE; static final String GROUP; static final String DIRECT; }### Answer: @Test public void shouldCheckIfReceived() throws Exception { WhatsAppMessage m = new WhatsAppMessage(); assertThat(m.isReceived()).isTrue(); m.key_from_me = 1; assertThat(m.isReceived()).isFalse(); }
### Question: WhatsAppMessage implements Comparable<WhatsAppMessage> { static String filterPrivateBlock(String s) { if (s == null) return null; final StringBuilder sb = new StringBuilder(); for (int i=0; i<s.length(); ) { int codepoint = s.codePointAt(i); Character.UnicodeBlock block = Character.UnicodeBlock.of(codepoint); if (block != Character.UnicodeBlock.PRIVATE_USE_AREA) { sb.append(Character.toChars(codepoint)); } i += Character.charCount(codepoint); } return sb.toString(); } WhatsAppMessage(); WhatsAppMessage(Cursor c); long getId(); boolean isReceived(); Date getTimestamp(); String getText(); String getFilteredText(); int getStatus(); double getLongitude(); double getLatitude(); int getRecipientCount(); String getNumber(); Media getMedia(); Receipt getReceipt(); boolean hasMediaAttached(); boolean hasText(); @Override String toString(); @Override int compareTo(WhatsAppMessage another); boolean isDirectMessage(); boolean isGroupMessage(); static final String TABLE; static final String GROUP; static final String DIRECT; }### Answer: @Test public void shouldFilterPrivateUnicodeCharacters() throws Exception { byte[] b = new byte[] { (byte) 0xee, (byte) 0x90, (byte) 0x87, (byte) 0xf0, (byte) 0x9f, (byte) 0x98, (byte) 0xa4, (byte) 0xee, (byte) 0x84, (byte) 0x87 }; String s = new String(b, Charset.forName("UTF-8")); assertThat(s.length()).isEqualTo(4); String filtered = WhatsAppMessage.filterPrivateBlock(s); assertThat(filtered).isEqualTo("\uD83D\uDE24"); assertThat(filtered.length()).isEqualTo(2); } @Test public void shouldFilterPrivateUnicodeCharactersNull() throws Exception { assertThat(WhatsAppMessage.filterPrivateBlock(null)).isNull(); }
### Question: Media { public File getFile() { MediaData md = getMediaData(); return md == null ? null : md.getFile(); } Media(); Media(Cursor c); byte[] getRawData(); String getMimeType(); String getUrl(); int getSize(); File getFile(); long getFileSize(); @Override String toString(); }### Answer: @Test public void shouldHandleSerializedDataOfWrongType() throws Exception { Media media = new Media(); media.thumb_image = fileToBytes(Fixtures.VECTOR_SERIALIZED); assertThat(media.getFile()).isNull(); } @Test public void shouldHandleInvalidSerializedData() throws Exception { Media media = new Media(); media.thumb_image = new byte[] {(byte) 0xde, (byte) 0xad, (byte) 0xbe, (byte) 0xef}; assertThat(media.getFile()).isNull(); }
### Question: DBDecryptor implements Decryptor { protected void decryptStream(InputStream in, OutputStream out) throws GeneralSecurityException, IOException { Cipher cipher = getCipher(Cipher.DECRYPT_MODE); CipherInputStream cis = null; try { cis = new CipherInputStream(in, cipher); byte[] buffer = new byte[8192]; int n; while ((n = cis.read(buffer)) != -1) { out.write(buffer, 0, n); } } finally { try { if (cis != null) cis.close(); out.close(); } catch (IOException ignored) {} } } void decryptDB(File input, File output); static void main(String[] args); }### Answer: @Test public void shouldDecryptStream() throws Exception { File out = File.createTempFile("db-test", ".sql"); FileOutputStream fos = new FileOutputStream(out); dbDecryptor.decryptStream(new FileInputStream(Fixtures.TEST_DB_1), fos); verifyDB(out); }
### Question: RepositoryPersonService implements PersonService { @Transactional(readOnly = true) @Override public List<Person> search(String searchTerm, int pageIndex) { LOGGER.debug("Searching persons with search term: " + searchTerm); return personRepository.findPersonsForPage(searchTerm, pageIndex); } @Transactional @Override Person create(PersonDTO created); @Transactional @Override long count(String searchTerm); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person delete(Long personId); @Transactional(readOnly = true) @Override List<Person> findAll(); @Transactional(readOnly = true) @Override Person findById(Long id); @Transactional(readOnly = true) @Override List<Person> search(String searchTerm, int pageIndex); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person update(PersonDTO updated); }### Answer: @Test public void search() { personService.search(SEARCH_TERM, PAGE_INDEX); verify(personRepositoryMock, times(1)).findPersonsForPage(SEARCH_TERM, PAGE_INDEX); verifyNoMoreInteractions(personRepositoryMock); }
### Question: PersonSpecifications { public static Specification<Person> lastNameIsLike(final String searchTerm) { return new Specification<Person>() { @Override public Predicate toPredicate(Root<Person> personRoot, CriteriaQuery<?> query, CriteriaBuilder cb) { String likePattern = getLikePattern(searchTerm); return cb.like(cb.lower(personRoot.<String>get(Person_.lastName)), likePattern); } private String getLikePattern(final String searchTerm) { StringBuilder pattern = new StringBuilder(); pattern.append(searchTerm.toLowerCase()); pattern.append("%"); return pattern.toString(); } }; } static Specification<Person> lastNameIsLike(final String searchTerm); }### Answer: @Test public void lastNameIsLike() { Path lastNamePathMock = mock(Path.class); when(personRootMock.get(Person_.lastName)).thenReturn(lastNamePathMock); Expression lastNameToLowerExpressionMock = mock(Expression.class); when(criteriaBuilderMock.lower(lastNamePathMock)).thenReturn(lastNameToLowerExpressionMock); Predicate lastNameIsLikePredicateMock = mock(Predicate.class); when(criteriaBuilderMock.like(lastNameToLowerExpressionMock, SEARCH_TERM_LIKE_PATTERN)).thenReturn(lastNameIsLikePredicateMock); Specification<Person> actual = PersonSpecifications.lastNameIsLike(SEARCH_TERM); Predicate actualPredicate = actual.toPredicate(personRootMock, criteriaQueryMock, criteriaBuilderMock); verify(personRootMock, times(1)).get(Person_.lastName); verifyNoMoreInteractions(personRootMock); verify(criteriaBuilderMock, times(1)).lower(lastNamePathMock); verify(criteriaBuilderMock, times(1)).like(lastNameToLowerExpressionMock, SEARCH_TERM_LIKE_PATTERN); verifyNoMoreInteractions(criteriaBuilderMock); verifyZeroInteractions(criteriaQueryMock, lastNamePathMock, lastNameIsLikePredicateMock); assertEquals(lastNameIsLikePredicateMock, actualPredicate); }
### Question: RepositoryPersonService implements PersonService { @Transactional(rollbackFor = PersonNotFoundException.class) @Override public Person update(PersonDTO updated) throws PersonNotFoundException { LOGGER.debug("Updating person with information: " + updated); Person person = personRepository.findOne(updated.getId()); if (person == null) { LOGGER.debug("No person found with id: " + updated.getId()); throw new PersonNotFoundException(); } person.update(updated.getFirstName(), updated.getLastName()); return person; } @Transactional @Override Person create(PersonDTO created); @Transactional @Override long count(String searchTerm); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person delete(Long personId); @Transactional(readOnly = true) @Override List<Person> findAll(); @Transactional(readOnly = true) @Override Person findById(Long id); @Transactional(readOnly = true) @Override List<Person> search(String searchTerm, int pageIndex); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person update(PersonDTO updated); }### Answer: @Test public void update() throws PersonNotFoundException { PersonDTO updated = PersonTestUtil.createDTO(PERSON_ID, FIRST_NAME_UPDATED, LAST_NAME_UPDATED); Person person = PersonTestUtil.createModelObject(PERSON_ID, FIRST_NAME, LAST_NAME); when(personRepositoryMock.findOne(updated.getId())).thenReturn(person); Person returned = personService.update(updated); verify(personRepositoryMock, times(1)).findOne(updated.getId()); verifyNoMoreInteractions(personRepositoryMock); assertPerson(updated, returned); } @Test(expected = PersonNotFoundException.class) public void updateWhenPersonIsNotFound() throws PersonNotFoundException { PersonDTO updated = PersonTestUtil.createDTO(PERSON_ID, FIRST_NAME_UPDATED, LAST_NAME_UPDATED); when(personRepositoryMock.findOne(updated.getId())).thenReturn(null); personService.update(updated); verify(personRepositoryMock, times(1)).findOne(updated.getId()); verifyNoMoreInteractions(personRepositoryMock); }
### Question: Person { @PrePersist public void prePersist() { Date now = new Date(); creationTime = now; modificationTime = now; } Long getId(); static Builder getBuilder(String firstName, String lastName); Date getCreationTime(); String getFirstName(); String getLastName(); @Transient String getName(); Date getModificationTime(); long getVersion(); void update(String firstName, String lastName); @PreUpdate void preUpdate(); @PrePersist void prePersist(); @Override String toString(); void setId(Long id); }### Answer: @Test public void prePersist() { Person built = Person.getBuilder(FIRST_NAME, LAST_NAME).build(); built.prePersist(); Date creationTime = built.getCreationTime(); Date modificationTime = built.getModificationTime(); assertNotNull(creationTime); assertNotNull(modificationTime); assertEquals(creationTime, modificationTime); }
### Question: Person { @PreUpdate public void preUpdate() { modificationTime = new Date(); } Long getId(); static Builder getBuilder(String firstName, String lastName); Date getCreationTime(); String getFirstName(); String getLastName(); @Transient String getName(); Date getModificationTime(); long getVersion(); void update(String firstName, String lastName); @PreUpdate void preUpdate(); @PrePersist void prePersist(); @Override String toString(); void setId(Long id); }### Answer: @Test public void preUpdate() { Person built = Person.getBuilder(FIRST_NAME, LAST_NAME).build(); built.prePersist(); try { Thread.sleep(1000); } catch (InterruptedException e) { } built.preUpdate(); Date creationTime = built.getCreationTime(); Date modificationTime = built.getModificationTime(); assertNotNull(creationTime); assertNotNull(modificationTime); assertTrue(modificationTime.after(creationTime)); }
### Question: AbstractController { protected void addErrorMessage(RedirectAttributes model, String code, Object... params) { LOGGER.debug("adding error message with code: " + code + " and params: " + params); Locale current = LocaleContextHolder.getLocale(); LOGGER.debug("Current locale is " + current); String localizedErrorMessage = messageSource.getMessage(code, params, current); LOGGER.debug("Localized message is: " + localizedErrorMessage); model.addFlashAttribute(FLASH_ERROR_MESSAGE, localizedErrorMessage); } }### Answer: @Test public void addErrorMessage() { RedirectAttributes model = new RedirectAttributesModelMap(); Object[] params = new Object[0]; when(messageSourceMock.getMessage(eq(ERROR_MESSAGE_CODE), eq(params), any(Locale.class))).thenReturn(ERROR_MESSAGE); controller.addErrorMessage(model, ERROR_MESSAGE_CODE, params); verify(messageSourceMock, times(1)).getMessage(eq(ERROR_MESSAGE_CODE), eq(params), any(Locale.class)); verifyNoMoreInteractions(messageSourceMock); String errorMessage = (String) model.getFlashAttributes().get(FLASH_ERROR_MESSAGE); assertEquals(ERROR_MESSAGE, errorMessage); }
### Question: AbstractController { protected void addFeedbackMessage(RedirectAttributes model, String code, Object... params) { LOGGER.debug("Adding feedback message with code: " + code + " and params: " + params); Locale current = LocaleContextHolder.getLocale(); LOGGER.debug("Current locale is " + current); String localizedFeedbackMessage = messageSource.getMessage(code, params, current); LOGGER.debug("Localized message is: " + localizedFeedbackMessage); model.addFlashAttribute(FLASH_FEEDBACK_MESSAGE, localizedFeedbackMessage); } }### Answer: @Test public void addFeedbackMessage() { RedirectAttributes model = new RedirectAttributesModelMap(); Object[] params = new Object[0]; when(messageSourceMock.getMessage(eq(FEEDBACK_MESSAGE_CODE), eq(params), any(Locale.class))).thenReturn(FEEDBACK_MESSAGE); controller.addFeedbackMessage(model, FEEDBACK_MESSAGE_CODE, params); verify(messageSourceMock, times(1)).getMessage(eq(FEEDBACK_MESSAGE_CODE), eq(params), any(Locale.class)); verifyNoMoreInteractions(messageSourceMock); String feedbackMessage = (String) model.getFlashAttributes().get(FLASH_FEEDBACK_MESSAGE); assertEquals(FEEDBACK_MESSAGE, feedbackMessage); }
### Question: AbstractController { protected String createRedirectViewPath(String path) { StringBuilder builder = new StringBuilder(); builder.append(VIEW_REDIRECT_PREFIX); builder.append(path); return builder.toString(); } }### Answer: @Test public void createRedirectViewPath() { String redirectView = controller.createRedirectViewPath(REDIRECT_PATH); String expectedView = buildExpectedRedirectViewPath(REDIRECT_PATH); verifyZeroInteractions(messageSourceMock); assertEquals(expectedView, redirectView); }
### Question: PaginatingPersonRepositoryImpl implements PaginatingPersonRepository { @Override public List<Person> findAllPersons() { LOGGER.debug("Finding all persons"); return personRepository.findAll(sortByLastNameAsc()); } PaginatingPersonRepositoryImpl(); @Override List<Person> findAllPersons(); @Override long findPersonCount(String searchTerm); @Override List<Person> findPersonsForPage(String searchTerm, int page); @PostConstruct void init(); }### Answer: @Test public void findAllPersons() { repository.findAllPersons(); ArgumentCaptor<Sort> sortArgument = ArgumentCaptor.forClass(Sort.class); verify(personRepositoryMock, times(1)).findAll(sortArgument.capture()); Sort sort = sortArgument.getValue(); assertEquals(Sort.Direction.ASC, sort.getOrderFor(PROPERTY_LASTNAME).getDirection()); }
### Question: PaginatingPersonRepositoryImpl implements PaginatingPersonRepository { @Override public long findPersonCount(String searchTerm) { LOGGER.debug("Finding person count with search term: " + searchTerm); return personRepository.count(lastNameIsLike(searchTerm)); } PaginatingPersonRepositoryImpl(); @Override List<Person> findAllPersons(); @Override long findPersonCount(String searchTerm); @Override List<Person> findPersonsForPage(String searchTerm, int page); @PostConstruct void init(); }### Answer: @Test public void findPersonCount() { when(personRepositoryMock.count(any(Predicate.class))).thenReturn(PERSON_COUNT); long actual = repository.findPersonCount(SEARCH_TERM); verify(personRepositoryMock, times(1)).count(any(Predicate.class)); verifyNoMoreInteractions(personRepositoryMock); assertEquals(PERSON_COUNT, actual); }
### Question: PaginatingPersonRepositoryImpl implements PaginatingPersonRepository { @Override public List<Person> findPersonsForPage(String searchTerm, int page) { LOGGER.debug("Finding persons for page " + page + " with search term: " + searchTerm); Page requestedPage = personRepository.findAll(lastNameIsLike(searchTerm), constructPageSpecification(page)); return requestedPage.getContent(); } PaginatingPersonRepositoryImpl(); @Override List<Person> findAllPersons(); @Override long findPersonCount(String searchTerm); @Override List<Person> findPersonsForPage(String searchTerm, int page); @PostConstruct void init(); }### Answer: @Test public void findPersonsForPage() { List<Person> expected = new ArrayList<Person>(); Page foundPage = new PageImpl<Person>(expected); when(personRepositoryMock.findAll(any(Predicate.class), any(Pageable.class))).thenReturn(foundPage); List<Person> actual = repository.findPersonsForPage(SEARCH_TERM, PAGE_INDEX); ArgumentCaptor<Pageable> pageSpecificationArgument = ArgumentCaptor.forClass(Pageable.class); verify(personRepositoryMock, times(1)).findAll(any(Predicate.class), pageSpecificationArgument.capture()); verifyNoMoreInteractions(personRepositoryMock); Pageable pageSpecification = pageSpecificationArgument.getValue(); assertEquals(PAGE_INDEX, pageSpecification.getPageNumber()); assertEquals(PaginatingPersonRepositoryImpl.NUMBER_OF_PERSONS_PER_PAGE, pageSpecification.getPageSize()); assertEquals(Sort.Direction.ASC, pageSpecification.getSort().getOrderFor(PROPERTY_LASTNAME).getDirection()); assertEquals(expected, actual); }
### Question: PreCondition { public static void isTrue(boolean expression, String errorMessageTemplate, Object... errorMessageArguments) { isTrue(expression, String.format(errorMessageTemplate, errorMessageArguments)); } private PreCondition(); static void isTrue(boolean expression, String errorMessageTemplate, Object... errorMessageArguments); static void isTrue(boolean expression, String errorMessage); static void notEmpty(String string, String errorMessage); static void notNull(Object reference, String errorMessage); }### Answer: @Test public void isTrueWithDynamicErrorMessage_ExpressionIsTrue_ShouldNotThrowException() { PreCondition.isTrue(true, "Dynamic error message with parameter: %d", 1L); } @Test public void isTrueWithDynamicErrorMessage_ExpressionIsFalse_ShouldThrowException() { assertThatThrownBy(() -> PreCondition.isTrue(false, "Dynamic error message with parameter: %d", 1L)) .isExactlyInstanceOf(IllegalArgumentException.class) .hasMessage("Dynamic error message with parameter: 1"); } @Test public void isTrueWithStaticErrorMessage_ExpressionIsTrue_ShouldNotThrowException() { PreCondition.isTrue(true, STATIC_ERROR_MESSAGE); } @Test public void isTrueWithStaticErrorMessage_ExpressionIsFalse_ShouldThrowException() { assertThatThrownBy(() -> PreCondition.isTrue(false, STATIC_ERROR_MESSAGE)) .isExactlyInstanceOf(IllegalArgumentException.class) .hasMessage(STATIC_ERROR_MESSAGE); }
### Question: Person { public void update(String firstName, String lastName) { this.firstName = firstName; this.lastName = lastName; } Long getId(); static Builder getBuilder(String firstName, String lastName); Date getCreationTime(); String getFirstName(); String getLastName(); @Transient String getName(); Date getModificationTime(); long getVersion(); void update(String firstName, String lastName); @PreUpdate void preUpdate(); @PrePersist void prePersist(); @Override String toString(); void setId(Long id); }### Answer: @Test public void update() { Person built = Person.getBuilder(FIRST_NAME, LAST_NAME).build(); built.update(FIRST_NAME_UPDATED, LAST_NAME_UPDATED); assertEquals(FIRST_NAME_UPDATED, built.getFirstName()); assertEquals(LAST_NAME_UPDATED, built.getLastName()); }
### Question: PreCondition { public static void notEmpty(String string, String errorMessage) { if (string.isEmpty()) { throw new IllegalArgumentException(errorMessage); } } private PreCondition(); static void isTrue(boolean expression, String errorMessageTemplate, Object... errorMessageArguments); static void isTrue(boolean expression, String errorMessage); static void notEmpty(String string, String errorMessage); static void notNull(Object reference, String errorMessage); }### Answer: @Test public void notEmpty_StringIsNotEmpty_ShouldNotThrowException() { PreCondition.notEmpty(" ", STATIC_ERROR_MESSAGE); } @Test public void notEmpty_StringIsEmpty_ShouldThrowException() { assertThatThrownBy(() -> PreCondition.notEmpty("", STATIC_ERROR_MESSAGE)) .isExactlyInstanceOf(IllegalArgumentException.class) .hasMessage(STATIC_ERROR_MESSAGE); }
### Question: PreCondition { public static void notNull(Object reference, String errorMessage) { if (reference == null) { throw new NullPointerException(errorMessage); } } private PreCondition(); static void isTrue(boolean expression, String errorMessageTemplate, Object... errorMessageArguments); static void isTrue(boolean expression, String errorMessage); static void notEmpty(String string, String errorMessage); static void notNull(Object reference, String errorMessage); }### Answer: @Test public void notNull_ObjectIsNotNull_ShouldNotThrowException() { PreCondition.notNull(new Object(), STATIC_ERROR_MESSAGE); } @Test public void notNull_ObjectIsNull_ShouldThrowException() { assertThatThrownBy(() -> PreCondition.notNull(null, STATIC_ERROR_MESSAGE)) .isExactlyInstanceOf(NullPointerException.class) .hasMessage(STATIC_ERROR_MESSAGE); }
### Question: RepositoryPersonService implements PersonService { @Transactional @Override public long count(String searchTerm) { LOGGER.debug("Getting person count for search term: " + searchTerm); return personRepository.findPersonCount(searchTerm); } @Transactional @Override Person create(PersonDTO created); @Transactional @Override long count(String searchTerm); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person delete(Long personId); @Transactional(readOnly = true) @Override List<Person> findAll(); @Transactional(readOnly = true) @Override Person findById(Long id); @Transactional(readOnly = true) @Override List<Person> search(String searchTerm, int pageIndex); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person update(PersonDTO updated); }### Answer: @Test public void count() { personService.count(SEARCH_TERM); verify(personRepositoryMock, times(1)).findPersonCount(SEARCH_TERM); verifyNoMoreInteractions(personRepositoryMock); }
### Question: RepositoryPersonService implements PersonService { @Transactional @Override public Person create(PersonDTO created) { LOGGER.debug("Creating a new person with information: " + created); Person person = Person.getBuilder(created.getFirstName(), created.getLastName()).build(); return personRepository.save(person); } @Transactional @Override Person create(PersonDTO created); @Transactional @Override long count(String searchTerm); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person delete(Long personId); @Transactional(readOnly = true) @Override List<Person> findAll(); @Transactional(readOnly = true) @Override Person findById(Long id); @Transactional(readOnly = true) @Override List<Person> search(String searchTerm, int pageIndex); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person update(PersonDTO updated); }### Answer: @Test public void create() { PersonDTO created = PersonTestUtil.createDTO(null, FIRST_NAME, LAST_NAME); Person persisted = PersonTestUtil.createModelObject(PERSON_ID, FIRST_NAME, LAST_NAME); when(personRepositoryMock.save(any(Person.class))).thenReturn(persisted); Person returned = personService.create(created); ArgumentCaptor<Person> personArgument = ArgumentCaptor.forClass(Person.class); verify(personRepositoryMock, times(1)).save(personArgument.capture()); verifyNoMoreInteractions(personRepositoryMock); assertPerson(created, personArgument.getValue()); assertEquals(persisted, returned); }
### Question: RepositoryPersonService implements PersonService { @Transactional(rollbackFor = PersonNotFoundException.class) @Override public Person delete(Long personId) throws PersonNotFoundException { LOGGER.debug("Deleting person with id: " + personId); Person deleted = personRepository.findOne(personId); if (deleted == null) { LOGGER.debug("No person found with id: " + personId); throw new PersonNotFoundException(); } personRepository.delete(deleted); return deleted; } @Transactional @Override Person create(PersonDTO created); @Transactional @Override long count(String searchTerm); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person delete(Long personId); @Transactional(readOnly = true) @Override List<Person> findAll(); @Transactional(readOnly = true) @Override Person findById(Long id); @Transactional(readOnly = true) @Override List<Person> search(String searchTerm, int pageIndex); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person update(PersonDTO updated); }### Answer: @Test public void delete() throws PersonNotFoundException { Person deleted = PersonTestUtil.createModelObject(PERSON_ID, FIRST_NAME, LAST_NAME); when(personRepositoryMock.findOne(PERSON_ID)).thenReturn(deleted); Person returned = personService.delete(PERSON_ID); verify(personRepositoryMock, times(1)).findOne(PERSON_ID); verify(personRepositoryMock, times(1)).delete(deleted); verifyNoMoreInteractions(personRepositoryMock); assertEquals(deleted, returned); } @Test(expected = PersonNotFoundException.class) public void deleteWhenPersonIsNotFound() throws PersonNotFoundException { when(personRepositoryMock.findOne(PERSON_ID)).thenReturn(null); personService.delete(PERSON_ID); verify(personRepositoryMock, times(1)).findOne(PERSON_ID); verifyNoMoreInteractions(personRepositoryMock); }
### Question: Person { @Transient public String getName() { StringBuilder name = new StringBuilder(); name.append(firstName); name.append(" "); name.append(lastName); return name.toString(); } Long getId(); static Builder getBuilder(String firstName, String lastName); Date getCreationTime(); String getFirstName(); String getLastName(); @Transient String getName(); Date getModificationTime(); long getVersion(); void update(String firstName, String lastName); @PreUpdate void preUpdate(); @PrePersist void prePersist(); @Override String toString(); void setId(Long id); }### Answer: @Test public void getName() { Person built = Person.getBuilder(FIRST_NAME, LAST_NAME).build(); String expectedName = constructName(FIRST_NAME, LAST_NAME); assertEquals(expectedName, built.getName()); }
### Question: RepositoryPersonService implements PersonService { @Transactional @Override public long count(String searchTerm) { LOGGER.debug("Getting person count for search term: " + searchTerm); return personRepository.count(lastNameIsLike(searchTerm)); } @Transactional @Override Person create(PersonDTO created); @Transactional @Override long count(String searchTerm); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person delete(Long personId); @Transactional(readOnly = true) @Override List<Person> findAll(); @Transactional(readOnly = true) @Override Person findById(Long id); @Transactional(readOnly = true) @Override List<Person> search(String searchTerm, int pageIndex); @Transactional(rollbackFor = PersonNotFoundException.class) @Override Person update(PersonDTO updated); }### Answer: @Test public void count() { when(personRepositoryMock.count(any(Specification.class))).thenReturn(PERSON_COUNT); long personCount = personService.count(SEARCH_TERM); verify(personRepositoryMock, times(1)).count(any(Specification.class)); verifyNoMoreInteractions(personRepositoryMock); assertEquals(PERSON_COUNT, personCount); }

Subsets and Splits