src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
CookieCollection implements Collection<Cookie> { @Override public Iterator<Cookie> iterator() { return cookieMap.values().iterator(); } CookieCollection(); CookieCollection(Cookie... cookies); CookieCollection(Collection<? extends Cookie> cookies); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<Cookie> iterator(); Cookie[] toArray(); @Override T[] toArray(T[] ts); @Override boolean add(Cookie cookie); @Override boolean remove(Object o); Cookie get(String name); @Override boolean containsAll(Collection<?> collection); @Override boolean addAll(Collection<? extends Cookie> collection); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override void clear(); } | @Test public void iterator() throws Exception { CookieCollection cookies = new CookieCollection(cookie); Iterator<Cookie> it = cookies.iterator(); Assert.assertTrue(it.hasNext()); Assert.assertEquals(cookie, it.next()); Assert.assertFalse(it.hasNext()); } |
CookieCollection implements Collection<Cookie> { public Cookie[] toArray() { Cookie[] cookies = new Cookie[cookieMap.size()]; return toArray(cookies); } CookieCollection(); CookieCollection(Cookie... cookies); CookieCollection(Collection<? extends Cookie> cookies); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<Cookie> iterator(); Cookie[] toArray(); @Override T[] toArray(T[] ts); @Override boolean add(Cookie cookie); @Override boolean remove(Object o); Cookie get(String name); @Override boolean containsAll(Collection<?> collection); @Override boolean addAll(Collection<? extends Cookie> collection); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override void clear(); } | @Test public void toArray() throws Exception { CookieCollection cookies = new CookieCollection(cookie); Cookie[] array = cookies.toArray(); Assert.assertEquals(cookies.size(), array.length); Assert.assertEquals(cookie, array[0]); } |
CookieCollection implements Collection<Cookie> { @Override public boolean add(Cookie cookie) { if (cookie == null) { return false; } cookieMap.put(cookie.getName(), cookie); return true; } CookieCollection(); CookieCollection(Cookie... cookies); CookieCollection(Collection<? extends Cookie> cookies); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<Cookie> iterator(); Cookie[] toArray(); @Override T[] toArray(T[] ts); @Override boolean add(Cookie cookie); @Override boolean remove(Object o); Cookie get(String name); @Override boolean containsAll(Collection<?> collection); @Override boolean addAll(Collection<? extends Cookie> collection); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override void clear(); } | @Test public void add() throws Exception { CookieCollection cookies = new CookieCollection(cookie); Cookie newCookie = new Cookie(BROWNIE_NAME, "mmh"); cookies.add(newCookie); Assert.assertEquals(2, cookies.size()); Assert.assertTrue(cookies.contains(newCookie)); Assert.assertTrue(cookies.contains(BROWNIE_NAME)); } |
Employee { public String toString() { return "Id: " + id + " Name:" + name + " Price:" + salary; } Employee(Integer id, String name, Double salary); Integer getId(); void setId(Integer id); String getName(); void setName(String name); Double getSalary(); void setSalary(Double salary); void salaryIncrement(Double percentage); String toString(); } | @Test public void whenCollectByJoining_thenGetJoinedString() { String empNames = empList.stream() .map(Employee::getName) .collect(Collectors.joining(", ")) .toString(); assertEquals(empNames, "Jeff Bezos, Bill Gates, Mark Zuckerberg"); } |
CookieCollection implements Collection<Cookie> { public Cookie get(String name) { return cookieMap.get(name); } CookieCollection(); CookieCollection(Cookie... cookies); CookieCollection(Collection<? extends Cookie> cookies); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<Cookie> iterator(); Cookie[] toArray(); @Override T[] toArray(T[] ts); @Override boolean add(Cookie cookie); @Override boolean remove(Object o); Cookie get(String name); @Override boolean containsAll(Collection<?> collection); @Override boolean addAll(Collection<? extends Cookie> collection); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override void clear(); } | @Test public void get() { CookieCollection cookies = new CookieCollection(cookie, brownieCookie, cupsCookie); Cookie c = cookies.get(COOKIE_NAME); Assert.assertNotNull(c); Assert.assertEquals(cookie, c); } |
CookieCollection implements Collection<Cookie> { @Override public boolean remove(Object o) { if (o instanceof String) { return cookieMap.remove((String)o) != null; } if (o instanceof Cookie) { Cookie c = (Cookie)o; return cookieMap.remove(c.getName()) != null; } return false; } CookieCollection(); CookieCollection(Cookie... cookies); CookieCollection(Collection<? extends Cookie> cookies); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<Cookie> iterator(); Cookie[] toArray(); @Override T[] toArray(T[] ts); @Override boolean add(Cookie cookie); @Override boolean remove(Object o); Cookie get(String name); @Override boolean containsAll(Collection<?> collection); @Override boolean addAll(Collection<? extends Cookie> collection); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override void clear(); } | @Test public void remove() throws Exception { CookieCollection cookies = new CookieCollection(cookie, brownieCookie, cupsCookie); cookies.remove(cookie); Assert.assertEquals(2, cookies.size()); Assert.assertFalse(cookies.contains(cookie)); Assert.assertFalse(cookies.contains(COOKIE_NAME)); Assert.assertTrue(cookies.contains(brownieCookie)); Assert.assertTrue(cookies.contains(BROWNIE_NAME)); } |
CookieCollection implements Collection<Cookie> { @Override public boolean containsAll(Collection<?> collection) { for(Object o : collection) { if (!contains(o)) { return false; } } return true; } CookieCollection(); CookieCollection(Cookie... cookies); CookieCollection(Collection<? extends Cookie> cookies); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<Cookie> iterator(); Cookie[] toArray(); @Override T[] toArray(T[] ts); @Override boolean add(Cookie cookie); @Override boolean remove(Object o); Cookie get(String name); @Override boolean containsAll(Collection<?> collection); @Override boolean addAll(Collection<? extends Cookie> collection); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override void clear(); } | @Test public void containsAll() throws Exception { List<Cookie> content = Arrays.asList(cookie, brownieCookie); CookieCollection cookies = new CookieCollection(content); Assert.assertTrue(cookies.containsAll(content)); Assert.assertTrue(cookies.containsAll(Collections.singletonList(cookie))); Assert.assertFalse(cookies.containsAll(Arrays.asList(cookie, brownieCookie, cupsCookie))); Assert.assertTrue(cookies.containsAll(Arrays.asList(COOKIE_NAME, BROWNIE_NAME))); } |
CookieCollection implements Collection<Cookie> { @Override public boolean addAll(Collection<? extends Cookie> collection) { boolean result = false; for(Cookie cookie : collection) { result|= add(cookie); } return result; } CookieCollection(); CookieCollection(Cookie... cookies); CookieCollection(Collection<? extends Cookie> cookies); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<Cookie> iterator(); Cookie[] toArray(); @Override T[] toArray(T[] ts); @Override boolean add(Cookie cookie); @Override boolean remove(Object o); Cookie get(String name); @Override boolean containsAll(Collection<?> collection); @Override boolean addAll(Collection<? extends Cookie> collection); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override void clear(); } | @Test @SuppressWarnings("unchecked") public void addAll() throws Exception { CookieCollection cookies = new CookieCollection(); List<Cookie> content = Arrays.asList(cookie, brownieCookie, cupsCookie); boolean modified = cookies.addAll(content); Assert.assertTrue(modified); Assert.assertEquals(3, cookies.size()); Assert.assertTrue(cookies.containsAll(content)); Assert.assertFalse(cookies.addAll(Collections.EMPTY_LIST)); } |
CookieCollection implements Collection<Cookie> { @Override public boolean removeAll(Collection<?> collection) { boolean result = false; for(Object cookie : collection) { result|= remove(cookie); } return result; } CookieCollection(); CookieCollection(Cookie... cookies); CookieCollection(Collection<? extends Cookie> cookies); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<Cookie> iterator(); Cookie[] toArray(); @Override T[] toArray(T[] ts); @Override boolean add(Cookie cookie); @Override boolean remove(Object o); Cookie get(String name); @Override boolean containsAll(Collection<?> collection); @Override boolean addAll(Collection<? extends Cookie> collection); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override void clear(); } | @Test public void removeAll() throws Exception { CookieCollection cookies = new CookieCollection(cookie, brownieCookie, cupsCookie); boolean modified = cookies.removeAll(Arrays.asList(brownieCookie, cupsCookie)); Assert.assertTrue(modified); Assert.assertEquals(1, cookies.size()); Assert.assertFalse(cookies.contains(brownieCookie)); Assert.assertFalse(cookies.contains(cupsCookie)); Assert.assertFalse(cookies.removeAll(Collections.EMPTY_LIST)); } |
CookieCollection implements Collection<Cookie> { @Override public boolean retainAll(Collection<?> collection) { boolean result = false; Iterator<Map.Entry<String, Cookie>> it = cookieMap.entrySet().iterator(); while(it.hasNext()) { Map.Entry<String, Cookie> e = it.next(); if (!collection.contains(e.getKey()) && !collection.contains(e.getValue())) { it.remove(); result = true; } } return result; } CookieCollection(); CookieCollection(Cookie... cookies); CookieCollection(Collection<? extends Cookie> cookies); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<Cookie> iterator(); Cookie[] toArray(); @Override T[] toArray(T[] ts); @Override boolean add(Cookie cookie); @Override boolean remove(Object o); Cookie get(String name); @Override boolean containsAll(Collection<?> collection); @Override boolean addAll(Collection<? extends Cookie> collection); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override void clear(); } | @Test public void retainAll() throws Exception { CookieCollection cookies = new CookieCollection(cookie, brownieCookie, cupsCookie); List<Cookie> content = Arrays.asList(cookie, brownieCookie); boolean modified = cookies.retainAll(content); Assert.assertTrue(modified); Assert.assertEquals(2, cookies.size()); Assert.assertTrue(cookies.containsAll(content)); Assert.assertFalse(cookies.contains(cupsCookie)); Assert.assertFalse(cookies.retainAll(content)); } |
CookieCollection implements Collection<Cookie> { @Override public void clear() { cookieMap.clear(); } CookieCollection(); CookieCollection(Cookie... cookies); CookieCollection(Collection<? extends Cookie> cookies); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Iterator<Cookie> iterator(); Cookie[] toArray(); @Override T[] toArray(T[] ts); @Override boolean add(Cookie cookie); @Override boolean remove(Object o); Cookie get(String name); @Override boolean containsAll(Collection<?> collection); @Override boolean addAll(Collection<? extends Cookie> collection); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override void clear(); } | @Test public void clear() throws Exception { CookieCollection cookies = new CookieCollection(cookie); cookies.clear(); Assert.assertTrue(cookies.isEmpty()); } |
WebConfigurer implements ServletContextInitializer, WebServerFactoryCustomizer<WebServerFactory> { @Override public void onStartup(ServletContext servletContext) throws ServletException { if (env.getActiveProfiles().length != 0) { log.info("Web application configuration, using profiles: {}", (Object[]) env.getActiveProfiles()); } EnumSet<DispatcherType> disps = EnumSet.of(DispatcherType.REQUEST, DispatcherType.FORWARD, DispatcherType.ASYNC); initMetrics(servletContext, disps); if (env.acceptsProfiles(JHipsterConstants.SPRING_PROFILE_PRODUCTION)) { initCachingHttpHeadersFilter(servletContext, disps); } if (env.acceptsProfiles(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT)) { initH2Console(servletContext); } log.info("Web application fully configured"); } WebConfigurer(Environment env, JHipsterProperties jHipsterProperties); @Override void onStartup(ServletContext servletContext); @Override void customize(WebServerFactory server); @Bean CorsFilter corsFilter(); @Autowired(required = false) void setMetricRegistry(MetricRegistry metricRegistry); } | @Test public void testStartUpProdServletContext() throws ServletException { env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_PRODUCTION); webConfigurer.onStartup(servletContext); assertThat(servletContext.getAttribute(InstrumentedFilter.REGISTRY_ATTRIBUTE)).isEqualTo(metricRegistry); assertThat(servletContext.getAttribute(MetricsServlet.METRICS_REGISTRY)).isEqualTo(metricRegistry); verify(servletContext).addFilter(eq("webappMetricsFilter"), any(InstrumentedFilter.class)); verify(servletContext).addServlet(eq("metricsServlet"), any(MetricsServlet.class)); verify(servletContext).addFilter(eq("cachingHttpHeadersFilter"), any(CachingHttpHeadersFilter.class)); verify(servletContext, never()).addServlet(eq("H2Console"), any(WebServlet.class)); }
@Test public void testStartUpDevServletContext() throws ServletException { env.setActiveProfiles(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT); webConfigurer.onStartup(servletContext); assertThat(servletContext.getAttribute(InstrumentedFilter.REGISTRY_ATTRIBUTE)).isEqualTo(metricRegistry); assertThat(servletContext.getAttribute(MetricsServlet.METRICS_REGISTRY)).isEqualTo(metricRegistry); verify(servletContext).addFilter(eq("webappMetricsFilter"), any(InstrumentedFilter.class)); verify(servletContext).addServlet(eq("metricsServlet"), any(MetricsServlet.class)); verify(servletContext, never()).addFilter(eq("cachingHttpHeadersFilter"), any(CachingHttpHeadersFilter.class)); verify(servletContext).addServlet(eq("H2Console"), any(WebServlet.class)); } |
QualityInvestmentPlanService { public QualityInvestmentPlan computeInvestmentPlan(QualityAnalysis analysis, String basePackage, int investmentInMinutes) { Multimap<Double, QualityViolation> violationsByProfit = ArrayListMultimap.create(); for (QualityViolation violation : filterViolationsByArtefactNameStartingWith(basePackage, analysis.getViolations())) { double profit = profitCalculator.calculateProfit(violation); if (Math.round(profit) > 0) { violationsByProfit.put(profit, violation); } } List<Double> allProfits = new ArrayList<Double>(); for (Double profit : violationsByProfit.keySet()) { int numberOfViolations = violationsByProfit.get(profit).size(); for (int i = 0; i < numberOfViolations; i++) { allProfits.add(profit); } } Collections.sort(allProfits, new DescendingComparator<Double>()); Set<QualityInvestmentPlanEntry> investmentPlanEntries = Sets.newTreeSet(); int toInvest = investmentInMinutes; int invested = 0; for (double profit : allProfits) { List<QualityViolation> violations = new ArrayList<QualityViolation>(violationsByProfit.get(profit)); Collections.sort(violations, new ViolationByRemediationCostsComparator()); for (QualityViolation violation : violations) { int remediationCost = violation.getRemediationCosts(); if (remediationCost <= toInvest) { invested += remediationCost; toInvest -= remediationCost; QualityRequirement requirement = violation.getRequirement(); investmentPlanEntries.add(new QualityInvestmentPlanEntry( requirement.getMetricIdentifier(), requirement.getOperator() + " " + requirement.getThreshold(), violation.getArtefact().getName(), violation.getArtefact().getShortClassName(), (int) Math.round(profit), remediationCost)); } } } final int overallProfit = calculateOverallProfit(investmentPlanEntries); return new QualityInvestmentPlan(basePackage, invested, overallProfit, calculateRoi(investmentPlanEntries, overallProfit), investmentPlanEntries); } @Autowired QualityInvestmentPlanService(ProfitCalculator profitCalculator); QualityInvestmentPlan computeInvestmentPlan(QualityAnalysis analysis, String basePackage, int investmentInMinutes); } | @Test public void zeroProfitWhenThereAreNoQualityViolations() { QualityAnalysis analysisWithoutViolations = QualityAnalysis.success(null, Collections.<QualityViolation>emptyList()); QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysisWithoutViolations, "", 100); assertThat(qualityInvestmentPlan.getProfitInMinutes()) .as("When there are no quality violations the overall profit should be zero.") .isZero(); }
@Test public void shouldGenerateInvestmentPlanForOneArtefact() { QualityViolation violation1 = new QualityViolation(new Artefact("org.project.A", ""), createRequirementOnlyWithCriteria(new QualityCriteria("cc", "<", 5.0)), 50, 0, 0.0, "ncloc"); QualityViolation violation2 = new QualityViolation(new Artefact("org.project.AB", ""), createRequirementOnlyWithCriteria(new QualityCriteria("rfc", "<=", 50.0)), 50, 0, 0.0, "ncloc"); QualityViolation violation3 = new QualityViolation(new Artefact("org.project.ABC", ""), createRequirementOnlyWithCriteria(new QualityCriteria("cov", ">", 80.0)), 10, 0, 0.0, "ncloc"); analysis = QualityAnalysis.success(null, Arrays.asList(violation1, violation2, violation3)); when(profitCalculator.calculateProfit(violation1)).thenReturn(100.0); QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysis, "org.project.A", 50); assertThat(qualityInvestmentPlan.getEntries()).hasSize(1); assertThat(qualityInvestmentPlan.getEntries().iterator().next().getArtefactLongName()).isEqualTo("org.project.A"); }
@Test public void shouldGenerateInvestmentPlanForOneSubPackage() { QualityViolation violation1 = new QualityViolation(new Artefact("org.project.a.test.A", ""), createRequirementOnlyWithCriteria(new QualityCriteria("cc", "<", 5.0)), 50, 0, 0.0, "ncloc"); QualityViolation violation2 = new QualityViolation(new Artefact("org.project.b.B", ""), createRequirementOnlyWithCriteria(new QualityCriteria("rfc", "<=", 50.0)), 50, 0, 0.0, "ncloc"); QualityViolation violation3 = new QualityViolation(new Artefact("org.project.C", ""), createRequirementOnlyWithCriteria(new QualityCriteria("cov", ">", 80.0)), 10, 0, 0.0, "ncloc"); analysis = QualityAnalysis.success(null, Arrays.asList(violation1, violation2, violation3)); when(profitCalculator.calculateProfit(violation1)).thenReturn(100.0); QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysis, "org.project.a.test.A", 50); assertThat(qualityInvestmentPlan.getEntries()).hasSize(1); assertThat(qualityInvestmentPlan.getEntries().iterator().next().getArtefactLongName()).isEqualTo("org.project.a.test.A"); }
@Test public void calculatesOverallProfitForAllQualityViolations() { QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysis, "", 80); assertThat(qualityInvestmentPlan.getProfitInMinutes()) .as("The overall profit should be calculated based on all quality violations.") .isEqualTo(300); assertThat(qualityInvestmentPlan.getInvestmentInMinutes()).isEqualTo(80); }
@Test public void whenInvestmentIsBiggerThanPossibleOverallProfitOnlyThePossibleProfitShouldBeCalculated() { QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysis, "", 100); assertThat(qualityInvestmentPlan.getProfitInMinutes()).isEqualTo(300); assertThat(qualityInvestmentPlan.getInvestmentInMinutes()).isEqualTo(80); }
@Test public void whenInvestmentIsSmallerThanPossibleOverallProfitOnlyTheInvestedAmountShouldBeCalculated() { QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysis, "", 35); assertThat(qualityInvestmentPlan.getProfitInMinutes()).isEqualTo(220); assertThat(qualityInvestmentPlan.getInvestmentInMinutes()).isEqualTo(20); }
@Test public void calculatesRoiBasedOnRemediationCostsAndProfit() { QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysis, "", 80); assertThat(qualityInvestmentPlan.getRoi()).isEqualTo(375); }
@Test public void containsAllQualityViolationsSortedByProfitAndRemediationCosts() { QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysis, "", 80); QualityInvestmentPlanEntry[] investments = qualityInvestmentPlan.getEntries().toArray(new QualityInvestmentPlanEntry[0]); assertThat(investments).hasSize(3); assertThat(investments[0].getArtefactLongName()).isEqualTo("C"); assertThat(investments[1].getArtefactLongName()).isEqualTo("org.A"); assertThat(investments[2].getArtefactLongName()).isEqualTo("org.project.B"); }
@Test public void shouldOnlyConsiderArtefactThatStartWithBasePackageName() { QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysis, "org.project", 80); assertThat(qualityInvestmentPlan.getEntries()).hasSize(1); assertThat(qualityInvestmentPlan.getEntries().iterator().next().getArtefactLongName()).isEqualTo("org.project.B"); }
@Test public void shouldChooseViolationsWithMoreProfit() { QualityViolation violation1 = new QualityViolation(new Artefact("org.A", ""), createRequirementOnlyWithCriteria(new QualityCriteria("cc", "<", 5.0)), 50, 0, 0.0, "ncloc"); QualityViolation violation2 = new QualityViolation(new Artefact("org.project.B", ""), createRequirementOnlyWithCriteria(new QualityCriteria("rfc", "<=", 50.0)), 50, 0, 0.0, "ncloc"); QualityViolation violation3 = new QualityViolation(new Artefact("C", ""), createRequirementOnlyWithCriteria(new QualityCriteria("cov", ">", 80.0)), 10, 0, 0.0, "ncloc"); analysis = QualityAnalysis.success(null, Arrays.asList(violation1, violation2, violation3)); QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysis, "", 50); assertThat(qualityInvestmentPlan.getEntries()).hasSize(1); assertThat(qualityInvestmentPlan.getEntries().iterator().next().getArtefactLongName()).isEqualTo("C"); }
@Test public void shouldChooseViolationWithBiggerRoiWhenProfitIsTheSame() { QualityViolation violationWithSmallerRoi = new QualityViolation(new Artefact("org.A", ""), createRequirementOnlyWithCriteria(new QualityCriteria("cc", "<", 5.0)), 50, 0, 0.0, "ncloc"); QualityViolation violationWithBiggerRoi = new QualityViolation(new Artefact("B", ""), createRequirementOnlyWithCriteria(new QualityCriteria("rfc", "<=", 50.0)), 40, 0, 0.0, "ncloc"); analysis = QualityAnalysis.success(null, Arrays.asList(violationWithSmallerRoi, violationWithBiggerRoi)); when(profitCalculator.calculateProfit(violationWithSmallerRoi)).thenReturn(100.0); when(profitCalculator.calculateProfit(violationWithBiggerRoi)).thenReturn(100.0); QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysis, "", 50); assertThat(qualityInvestmentPlan.getEntries()).hasSize(1); assertThat(qualityInvestmentPlan.getEntries().iterator().next().getArtefactLongName()).isEqualTo("B"); }
@Test public void shouldNotConsiderViolationsWithNegativeProfit() { when(profitCalculator.calculateProfit(any(QualityViolation.class))).thenReturn(-0.1); QualityInvestmentPlan qualityInvestmentPlan = investmentPlanService.computeInvestmentPlan(analysis, "", 50); assertThat(qualityInvestmentPlan.getProfitInMinutes()).isZero(); assertThat(qualityInvestmentPlan.getRoi()).isZero(); assertThat(qualityInvestmentPlan.getEntries()).isEmpty(); } |
InvestmentOpportunitiesJsonGenerator { public String generate(QualityAnalysis analysis) throws JsonProcessingException { Set<String> alreadyAddedArtefacts = Sets.newHashSet(); Map<String, PackageNode> nodeLookupTable = Maps.newHashMap(); RootNode rootNode = new RootNode(analysis.getProject().getName()); for (QualityViolation violation : analysis.getViolations()) { addArtefact(violation, rootNode, alreadyAddedArtefacts, nodeLookupTable); } rootNode.filterProfitableChildren(); rootNode.updateChangeProbabilityOfProfitableChildren(); rootNode.updateAutomaticChangeProbabilityAndEstimateOfAllChildren(); return MAPPER.writeValueAsString(rootNode); } @Autowired InvestmentOpportunitiesJsonGenerator(WeightedProfitCalculator weightedProfitCalculator); String generate(QualityAnalysis analysis); } | @Test public void profitablePacakgesAndArtefactsShouldBeFilteredProperly() throws IOException { Artefact artefact1 = new Artefact("org.project.test.util.C", "DUMMY"); Artefact artefact2 = new Artefact("org.project.test.util.D", "DUMMY"); Artefact artefact3 = new Artefact("org.project.test.E", "DUMMY"); Artefact artefact4 = new Artefact("org.project.F", "DUMMY"); artefact1.setChangeProbability(0.1); artefact1.setManualEstimate(40); artefact2.setChangeProbability(0.2); artefact2.setManualEstimate(80); artefact3.setChangeProbability(0.0); artefact4.setChangeProbability(0.0); QualityViolation violation1 = new QualityViolation(artefact1, null, 0, 0, 0, ""); QualityViolation violation2 = new QualityViolation(artefact2, null, 0, 0, 0, ""); QualityViolation violation3 = new QualityViolation(artefact3, null, 0, 0, 0, ""); QualityViolation violation4 = new QualityViolation(artefact4, null, 0, 0, 0, ""); QualityAnalysis analysis = QualityAnalysis.success(project, Arrays.asList(violation1, violation2, violation3, violation4)); when(weightedProfitCalculator.calculateWeightedProfit(violation1)).thenReturn(10.0); when(weightedProfitCalculator.calculateWeightedProfit(violation2)).thenReturn(20.0); when(weightedProfitCalculator.calculateWeightedProfit(violation3)).thenReturn(-10.0); when(weightedProfitCalculator.calculateWeightedProfit(violation4)).thenReturn(-20.0); JsonNode generatedJson = generate(analysis); ArrayNode rootPackagNode = (ArrayNode) generatedJson.get("children"); assertThat(rootPackagNode.get(0).get("changeProbability").asInt()).isEqualTo(60); }
@Test public void emptyAnalysis() throws IOException { QualityAnalysis analysis = QualityAnalysis.success(project, Collections.<QualityViolation>emptyList()); String expectedJson = "{ \"name\": \"Dummy Project\", \"allChildren\": [], \"children\": []}"; assertThat(generate(analysis).toString()).isEqualTo(mapper.readTree(expectedJson).toString()); }
@Test public void analysisWithOneArtefact() throws IOException { Artefact artefact = new Artefact("org.project.MyClass", "DUMMY"); artefact.setChangeProbability(0.6); QualityViolation violation = new QualityViolation(artefact, null, 5, 10, 0, ""); QualityAnalysis analysis = QualityAnalysis.success(project, Arrays.asList(violation)); when(weightedProfitCalculator.calculateWeightedProfit(violation)).thenReturn(1234.0); JsonNode generatedJson = generate(analysis); ArrayNode rootPackagNode = (ArrayNode) generatedJson.get("children"); assertThat(rootPackagNode.get(0).get("changeProbability").asInt()).isEqualTo(60); assertThat(rootPackagNode.get(0).get("children").get(0).get("children").get(0).get("value").asDouble()).isEqualTo(1234.0); }
@Test public void analysisWithManyArtefactsAndManyViolations() throws IOException { Artefact artefact1 = new Artefact("project.A", "DUMMY"); Artefact artefact2 = new Artefact("project.B", "DUMMY"); Artefact artefact3 = new Artefact("project.test.util.C", "DUMMY"); Artefact artefact4 = new Artefact("project.test.util.D", "DUMMY"); Artefact artefact5 = new Artefact("E", "DUMMY"); artefact1.setChangeProbability(0.1); artefact2.setChangeProbability(0.2); artefact3.setChangeProbability(0.3); artefact4.setChangeProbability(0.4); artefact5.setChangeProbability(0.5); QualityViolation violation1 = new QualityViolation(artefact1, null, 0, 0, 0, ""); QualityViolation violation2 = new QualityViolation(artefact2, null, 0, 0, 0, ""); QualityViolation violation3 = new QualityViolation(artefact3, null, 0, 0, 0, ""); QualityViolation violation4 = new QualityViolation(artefact4, null, 0, 0, 0, ""); QualityViolation violation5 = new QualityViolation(artefact5, null, 0, 0, 0, ""); QualityAnalysis analysis = QualityAnalysis.success(project, Arrays.asList(violation1, violation2, violation3, violation4, violation5)); when(weightedProfitCalculator.calculateWeightedProfit(violation1)).thenReturn(10.0); when(weightedProfitCalculator.calculateWeightedProfit(violation2)).thenReturn(20.0); when(weightedProfitCalculator.calculateWeightedProfit(violation3)).thenReturn(30.0); when(weightedProfitCalculator.calculateWeightedProfit(violation4)).thenReturn(40.0); when(weightedProfitCalculator.calculateWeightedProfit(violation5)).thenReturn(50.0); JsonNode generatedJson = generate(analysis); ArrayNode rootPackagNode = (ArrayNode) generatedJson.get("children"); assertThat(rootPackagNode.get(1).get("changeProbability").asInt()).isEqualTo(22); } |
ProjectValidator implements Validator { @Override public boolean supports(Class<?> clazz) { return Project.class.equals(clazz); } @Autowired ProjectValidator(ProjectRepository projectRepository,
QualityProfileRepository profileRepository,
SonarConnectionSettingsValidator sonarConnectionSettingsValidator,
ScmConnectionSettingsValidator scmConnectionSettingsValidator,
CodeChangeSettingsValidator codeChangeSettingsValidator); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); } | @Test public void shouldSupportProjectType() { assertThat(validator.supports(Project.class)).isTrue(); }
@Test public void shouldNotSupportOtherTypeThanProject() { assertThat(validator.supports(Object.class)).isFalse(); } |
CodeChangeSettingsValidator implements Validator { @Override public boolean supports(Class<?> clazz) { return CodeChangeSettings.class.equals(clazz); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); } | @Test public void shouldSupportCodeChangeSettingsType() { assertThat(validator.supports(CodeChangeSettings.class)).isTrue(); }
@Test public void shouldNotSupportOtherTypeThanCodeChangeSettings() { assertThat(validator.supports(Object.class)).isFalse(); } |
ProjectConnectionsValidator implements Validator { @Override public boolean supports(Class<?> clazz) { return Project.class.equals(clazz); } @Autowired ProjectConnectionsValidator(ProjectValidator projectValidator,
SonarConnectionCheckerService sonarConnectionCheckerService,
ScmAvailabilityCheckerServiceFactory scmAvailabilityCheckerServiceFactory); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); } | @Test public void shouldSupportProjectType() { assertThat(validator.supports(Project.class)).isTrue(); }
@Test public void shouldNotSupportOtherTypeThanProject() { assertThat(validator.supports(Object.class)).isFalse(); } |
ProjectConnectionsValidator implements Validator { @Override public void validate(Object target, Errors errors) { ValidationUtils.invokeValidator(projectValidator, target, errors); Project project = (Project) target; if (!sonarConnectionCheckerService.isReachable(project.getSonarConnectionSettings())) { errors.rejectValue("sonarConnectionSettings", "sonar.not.reachable"); } try { if (!scmAvailabilityCheckerServiceFactory.create(project.getScmSettings()).isAvailable(project.getScmSettings())) { scmSystemNotAvailable(errors); } } catch (UnsupportedScmSystem e) { scmSystemNotAvailable(errors); } } @Autowired ProjectConnectionsValidator(ProjectValidator projectValidator,
SonarConnectionCheckerService sonarConnectionCheckerService,
ScmAvailabilityCheckerServiceFactory scmAvailabilityCheckerServiceFactory); @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); } | @Test public void shouldCallSuppliedProjectValidator() { when(sonarConnectionCheckerService.isReachable(any(SonarConnectionSettings.class))).thenReturn(true); mockAvailableScmSystem(); validateProject(project); verify(projectValidator).validate(any(), any(Errors.class)); } |
ScmConnectionSettingsValidator implements Validator { @Override public boolean supports(Class<?> clazz) { return ScmConnectionSettings.class.equals(clazz); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); } | @Test public void shouldSupportScmConnectionSettingsType() { assertThat(validator.supports(ScmConnectionSettings.class)).isTrue(); }
@Test public void shouldNotSupportOtherTypeThanScmConnectionSettings() { assertThat(validator.supports(Object.class)).isFalse(); } |
InvestmentAmountParser { public int parseMinutes(String formattedInvestmentAmount) throws InvestmentParsingException { if (formattedInvestmentAmount.isEmpty()) { return 0; } Pattern pattern = Pattern.compile("(\\d*h)?\\s?(\\d*m)?"); Matcher matcher = pattern.matcher(formattedInvestmentAmount); int minutes = 0; if (!matcher.find()) { throw new InvestmentParsingException(); } String[] timeValues = matcher.group().split("\\s"); minutes += getMinutesFor(timeValues[0]); if (timeValues.length > 1) { minutes += getMinutesFor(timeValues[1]); } return minutes; } int parseMinutes(String formattedInvestmentAmount); } | @Test public void emptyStringShouldBeParsedToZeroMinutes() throws InvestmentParsingException { assertThat(parser.parseMinutes("")).isEqualTo(0); }
@Test public void shouldParseHoursProperly() throws InvestmentParsingException { assertThat(parser.parseMinutes("3h")).isEqualTo(180); }
@Test public void shouldParseMinutesProperly() throws InvestmentParsingException { assertThat(parser.parseMinutes("21m")).isEqualTo(21); }
@Test public void shouldParseHoursAndMinutesProperly() throws InvestmentParsingException { assertThat(parser.parseMinutes("3h 70m")).isEqualTo(250); }
@Test(expected = InvestmentParsingException.class) public void shouldThrowExceptionWhenGivenStringIsNotParsable() throws InvestmentParsingException { parser.parseMinutes("abc0m"); } |
ProfitCalculator { public double calculateProfit(QualityViolation violation) { double nonRemediationCosts = violation.getNonRemediationCosts() * (violation.getArtefact().hasManualEstimate() ? violation.getArtefact().getManualEstimate() / 100.0 : violation.getArtefact().getChangeProbability()); return violation.getRequirement().isAutomaticallyFixable() ? nonRemediationCosts - violation.getRemediationCosts() : nonRemediationCosts - violation.getRemediationCosts() * violation.getArtefact().getSecureChangeProbability(); } double calculateProfit(QualityViolation violation); } | @Test public void profitForAutomaticFixableViolation() { when(requirement.isAutomaticallyFixable()).thenReturn(true); assertThat(calculator.calculateProfit(violation)).isEqualTo(2.0); }
@Test public void profitForNotAutomaticFixableViolation() { when(requirement.isAutomaticallyFixable()).thenReturn(false); when(artefact.getSecureChangeProbability()).thenReturn(1.1); assertThat(calculator.calculateProfit(violation)).isEqualTo(1.0); }
@Test public void profitForViolationWhereArtefactHasManualEstimate() { when(requirement.isAutomaticallyFixable()).thenReturn(true); when(artefact.getManualEstimate()).thenReturn(80); when(artefact.hasManualEstimate()).thenReturn(true); assertThat(calculator.calculateProfit(violation)).isEqualTo(6.0); } |
WeightedProfitCalculator { public double calculateWeightedProfit(QualityViolation violation) { return profitCalculator.calculateProfit(violation) / violation.getWeightingMetricValue(); } @Autowired WeightedProfitCalculator(ProfitCalculator profitCalculator); double calculateWeightedProfit(QualityViolation violation); } | @Test public void shouldDivideProfitOfViolationByWeightingMetricValue() { ProfitCalculator profitCalculator = mock(ProfitCalculator.class); when(profitCalculator.calculateProfit(any(QualityViolation.class))).thenReturn(20.0); QualityViolation violation = mock(QualityViolation.class); when(violation.getWeightingMetricValue()).thenReturn(13.0); WeightedProfitCalculator weightedProfitCalculator = new WeightedProfitCalculator(profitCalculator); assertThat(weightedProfitCalculator.calculateWeightedProfit(violation)).isEqualTo(1.54, Delta.delta(0.01)); } |
CommitBasedCodeChangeProbabilityCalculator implements CodeChangeProbabilityCalculator { @Override public double calculateCodeChangeProbability(ScmConnectionSettings connectionSettings, String file) throws CodeChurnCalculationException, ScmConnectionEncodingException { log.info("Calculate code change probability for file {}", file); final CodeChurnCalculator codeChurnCalculator = codeChurnCalculatorFactory.create(connectionSettings); CodeChurn codeChurn = codeChurnCalculator.calculateCodeChurnForLastCommits(connectionSettings, file, numberOfCommits); double changeProbability = 0.0; for (Double codeChurnProportion : codeChurn.getCodeChurnProportions()) { changeProbability += codeChurnProportion * (1 / (double) numberOfCommits); } return Math.min(1.0, changeProbability); } CommitBasedCodeChangeProbabilityCalculator(CodeChurnCalculatorFactory codeChurnCalculatorFactory, int numberOfCommits); @Override double calculateCodeChangeProbability(ScmConnectionSettings connectionSettings, String file); } | @Test public void codeChurnForOneLastCommit() throws CodeChurnCalculationException, ScmConnectionEncodingException { fakeCodeChurnCalculator.addCodeChurnWithoutDay("A", new CodeChurn(Arrays.asList(0.8))); CodeChangeProbabilityCalculator codeChangeProbabilityCalculator = new CommitBasedCodeChangeProbabilityCalculator(codeChurnCalculatorFactory, 1); assertThat(codeChangeProbabilityCalculator.calculateCodeChangeProbability(dummyConnectionSettings, "A")).isEqualTo(0.8); }
@Test public void codeChurnForManyLastCommits() throws CodeChurnCalculationException, ScmConnectionEncodingException { fakeCodeChurnCalculator.addCodeChurnWithoutDay("A", new CodeChurn(Arrays.asList(0.8))); fakeCodeChurnCalculator.addCodeChurnWithoutDay("A", new CodeChurn(Arrays.asList(1.0))); fakeCodeChurnCalculator.addCodeChurnWithoutDay("A", new CodeChurn(Arrays.asList(0.2))); CodeChangeProbabilityCalculator codeChangeProbabilityCalculator = new CommitBasedCodeChangeProbabilityCalculator(codeChurnCalculatorFactory, 4); assertThat(codeChangeProbabilityCalculator.calculateCodeChangeProbability(dummyConnectionSettings, "A")).isEqualTo(0.5); }
@Test public void maxPossibleProbabilityShouldBeOne() throws CodeChurnCalculationException, ScmConnectionEncodingException { fakeCodeChurnCalculator.addCodeChurnWithoutDay("A", new CodeChurn(Arrays.asList(10.0))); CodeChangeProbabilityCalculator codeChangeProbabilityCalculator = new CommitBasedCodeChangeProbabilityCalculator(codeChurnCalculatorFactory, 1); assertThat(codeChangeProbabilityCalculator.calculateCodeChangeProbability(dummyConnectionSettings, "A")).isEqualTo(1.0); } |
CodeChurnCalculatorFactory { public CodeChurnCalculator create(ScmConnectionSettings connectionSettings) { if (connectionSettings.getType() == SupportedScmSystem.SVN.getType()) { return svnCodeChurnCalculator; } throw new UnsupportedScmSystem(); } @Autowired CodeChurnCalculatorFactory(SvnCodeChurnCalculatorService svnCodeChurnCalculator); CodeChurnCalculator create(ScmConnectionSettings connectionSettings); } | @Test(expected = UnsupportedScmSystem.class) public void shouldFailForNotSupportedSvmTypesWithException() { ScmConnectionSettings connectionSettings = mock(ScmConnectionSettings.class); when(connectionSettings.getType()).thenReturn(Integer.MAX_VALUE); codeChurnCalculatorFactory.create(connectionSettings); }
@Test public void createSvnCodeChurnCalculatorForSvnType() { ScmConnectionSettings connectionSettings = mock(ScmConnectionSettings.class); when(connectionSettings.getType()).thenReturn(SupportedScmSystem.SVN.getType()); assertThat(codeChurnCalculatorFactory.create(connectionSettings)).isInstanceOf(SvnCodeChurnCalculatorService.class); } |
SvnServerAvailabilityCheckerService implements ScmAvailabilityCheckerService { @Override public boolean isAvailable(ScmConnectionSettings connectionSettings) { if (connectionSettings == null || Strings.isNullOrEmpty(connectionSettings.getUrl())) { return false; } try { SvnRepositoryFactory.create(connectionSettings).testConnection(); log.info("The given svn server is reachable with connection settings: {}", connectionSettings); return true; } catch (SVNException e) { log.warn("The given svn server is not reachable during connection check.", e); return false; } } @Override boolean isAvailable(ScmConnectionSettings connectionSettings); } | @Test public void notAvailableWhenScmSettingsAreNull() { assertThat(availabilityCheckerService.isAvailable(null)).isFalse(); }
@Test public void notAvailableWhenUrlOfScmSettingsIsNull() { assertThat(availabilityCheckerService.isAvailable(new ScmConnectionSettings(null))).isFalse(); }
@Test public void notAvailableWhenUrlOfScmSettingsIsEmpty() { assertThat(availabilityCheckerService.isAvailable(new ScmConnectionSettings(""))).isFalse(); } |
SvnFileRevision { String getFilePartOfOldPath(ScmConnectionSettings connectionSettings) throws SVNException { SVNURL svnurl = SVNURL.parseURIEncoded(connectionSettings.getUrl()); List<String> splittedBasePath = splitUrl(svnurl.getPath()); List<String> splittedOldPath = splitUrl(oldPath); int i = 0; boolean foundBeginningOfSomeCommonParts = false; for (String s : splittedBasePath) { if (!foundBeginningOfSomeCommonParts && s.equalsIgnoreCase(splittedOldPath.get(0))) { foundBeginningOfSomeCommonParts = true; } if (foundBeginningOfSomeCommonParts) { i++; } } StringBuilder filePart = new StringBuilder(); boolean isFirst = true; for (; i < splittedOldPath.size(); i++) { if (!isFirst) { filePart.append('/'); } filePart.append(splittedOldPath.get(i)); isFirst = false; } return filePart.toString(); } } | @Test public void shouldParseFilePartOutOfOldPathProperly() throws SVNException { ScmConnectionSettings connectionSettings = new ScmConnectionSettings("http: SvnFileRevision fileRevision = new SvnFileRevision(0L, "/commons/proper/configuration/trunk/src/main/java/org/apache/commons/configuration/reloading/ManagedReloadingStrategy.java", null); assertThat(fileRevision.getFilePartOfOldPath(connectionSettings)).isEqualTo("org/apache/commons/configuration/reloading/ManagedReloadingStrategy.java"); } |
SvnFile { int countLines() { if (content.isEmpty()) { return 0; } return content.split(lineSeparator).length; } SvnFile(String content, String lineSeparator); } | @Test public void countLinesWithSuppliedSeparator() { assertThat(new SvnFile("1a2a3", "a").countLines()).isEqualTo(3); }
@Test public void shouldNotFailOnEmptyText() { assertThat(new SvnFile("", "a").countLines()).isEqualTo(0); }
@Test public void countLineCorrectlyWhenSeparatorConsistsOfManyCharacters() { assertThat(new SvnFile("111abc222abc333", "abc").countLines()).isEqualTo(3); } |
ProjectInformation implements Comparable { @Override public int compareTo(Object o) { if (o != null) { ProjectInformation otherProjectInformation = (ProjectInformation) o; if (otherProjectInformation.getName() != null && this.getName() != null) { return this.name.compareToIgnoreCase(otherProjectInformation.getName()); } } return 1; } ProjectInformation(); ProjectInformation(String name, String resourceKey); @Override int compareTo(Object o); } | @Test public void A_is_sorted_before_B() { assertThat(A.compareTo(B)).isEqualTo(comesBefore); }
@Test public void a_is_sorted_before_B() { assertThat(a.compareTo(B)).isEqualTo(comesBefore); }
@Test public void B_is_sorted_after_A() { assertThat(B.compareTo(A)).isEqualTo(comesAfter); }
@Test public void A_and_a_are_the_same() { assertThat(a.compareTo(A)).isEqualTo(areTheSame); }
@Test public void compared_to_null_is_the_same() { assertThat(B.compareTo(null)).isEqualTo(comesAfter); }
@Test public void compared_to_null_name_is_sorted_after() { assertThat(B.compareTo(nullName)).isEqualTo(comesAfter); }
@Test public void compared__valid_projectInfo_to_null_is_sorted_after() { assertThat(nullName.compareTo(A)).isEqualTo(comesAfter); } |
MetricCollectorService { public double collectMetricForResource(SonarConnectionSettings connectionSettings, String resourceKey, String metricIdentifier) throws ResourceNotFoundException { if (!connectionSettings.hasProject()) { throw new IllegalArgumentException("you can only collect metric value for a resource with connection settings that has a project"); } Sonar sonar = new Sonar(new HttpClient4Connector(connectionSettings.asHostObject())); Resource resource = sonar.find(ResourceQuery.create(resourceKey).setMetrics(metricIdentifier)); if (resource == null) { log.debug("Could not find measurement for metric {} at resource {}", metricIdentifier, resourceKey); return DEFAULT_VALUE; } Double metricValue = resource.getMeasureValue(metricIdentifier); if (metricValue == null) { log.error("Metric identifier " + metricIdentifier + " is not supported by the given Sonar server at " + connectionSettings.toString()); throw new ResourceNotFoundException("Could not find metric with identifier: " + metricIdentifier); } log.debug("{} = {} for {}", metricIdentifier, metricValue, resourceKey); return metricValue; } double collectMetricForResource(SonarConnectionSettings connectionSettings, String resourceKey, String metricIdentifier); } | @Test(expected = IllegalArgumentException.class) public void shouldFailWhenConnectionSettingsMissProjectAttribute() throws ResourceNotFoundException { new MetricCollectorService().collectMetricForResource(new SonarConnectionSettings("dummy"), "", ""); } |
ResourcesCollectorService { public Collection<Resource> collectAllResourcesForProject(SonarConnectionSettings connectionSettings) { if (!connectionSettings.hasProject()) { throw new IllegalArgumentException("you can only collect resources with connection settings that has a project"); } log.info("Start collecting all classes for project {} at Sonar server", connectionSettings.getProject()); Sonar sonar = new Sonar(new HttpClient4Connector(connectionSettings.asHostObject())); List<Resource> resources = sonar.findAll(ResourceQuery.create(connectionSettings.getProject()) .setAllDepths() .setScopes("FIL") .setQualifiers("FIL")); log.info("Found {} classes for project {}", resources.size(), connectionSettings.getProject()); return resources; } Collection<Resource> collectAllResourcesForProject(SonarConnectionSettings connectionSettings); } | @Test(expected = IllegalArgumentException.class) public void shouldFailWhenConnectionSettingsMissProjectAttribute() { new ResourcesCollectorService().collectAllResourcesForProject(new SonarConnectionSettings("dummy")); } |
SonarConnectionCheckerService { public boolean isReachable(SonarConnectionSettings connectionSettings) { if (connectionSettings == null || Strings.isNullOrEmpty(connectionSettings.getUrl())) { return false; } HttpClient4Connector connector = new HttpClient4Connector(connectionSettings.asHostObject()); try { return connector.getHttpClient() .execute(new HttpGet(connectionSettings.getUrl() + "/api/metrics")).getStatusLine().getStatusCode() == OK; } catch (IOException e) { log.info("Sonar is not reachable during connection check.", e); return false; } } boolean isReachable(SonarConnectionSettings connectionSettings); } | @Test public void notReachableWhenConnectionSettingsAreNull() { assertThat(sonarConnectionCheckerService.isReachable(null)).isFalse(); }
@Test public void notReachableWhenUrlOfConnectionSettingsIsNull() { assertThat(sonarConnectionCheckerService.isReachable(new SonarConnectionSettings(null))).isFalse(); }
@Test public void notReachableWhenUrlOfConnectionSettingsIsEmpty() { assertThat(sonarConnectionCheckerService.isReachable(new SonarConnectionSettings(""))).isFalse(); } |
DefaultQualityAnalyzerService implements QualityAnalyzerService { @Override public QualityAnalysis analyzeProject(Project project) { try { ViolationsAnalysisResult violationsAnalysisResult = violationsCalculatorService.calculateAllViolation(project); if (!violationsAnalysisResult.isSuccessful()) { log.error("Quality analysis for project {} failed due '{}'", project.getName(), violationsAnalysisResult.getFailureReason().get()); return qualityAnalysisRepository.save(QualityAnalysis.failed(project, zeroCostsForEachViolation(violationsAnalysisResult), violationsAnalysisResult.getFailureReason().get())); } log.info("Checking the availability of the SCM system {} for project {}", project.getScmSettings(), project.getName()); if (!scmAvailabilityCheckerServiceFactory.create(project.getScmSettings()).isAvailable(project.getScmSettings())) { return qualityAnalysisRepository.save(QualityAnalysis.failed(project, zeroCostsForEachViolation(violationsAnalysisResult), "The scm system is not available.")); } QualityAnalysis qualityAnalysis = addChangeProbabilityToEachArtifact(project, violationsAnalysisResult); if (!qualityAnalysis.isSuccessful()) { return qualityAnalysisRepository.save(qualityAnalysis); } qualityAnalysis = addSecureChangeProbabilityToEachArtifact(project, qualityAnalysis); log.info("Quality analysis succeeded for project {} with {} violations.", project.getName(), violationsAnalysisResult.getViolations().size()); return qualityAnalysisRepository.save(qualityAnalysis); } catch (Exception e) { String errorMessage = "Unexpected error occured during quality analysis!"; log.error(errorMessage, e); return QualityAnalysis.failed(project, new ArrayList<QualityViolation>(), errorMessage); } } @Autowired DefaultQualityAnalyzerService(ViolationsCalculatorService violationsCalculatorService,
ScmAvailabilityCheckerServiceFactory scmAvailabilityCheckerServiceFactory,
CodeChangeProbabilityCalculatorFactory codeChangeProbabilityCalculatorFactory,
SecureChangeProbabilityCalculator secureChangeProbabilityCalculator,
QualityViolationCostsCalculator costsCalculator,
QualityAnalysisRepository qualityAnalysisRepository); @Override QualityAnalysis analyzeProject(Project project); } | @Test public void succeededAnalysisWithOneViolation() throws CodeChurnCalculationException, ScmConnectionEncodingException { Artefact artefact = new Artefact("A", "A"); QualityAnalyzerService qualityAnalyzerService = createMockedSystemWithArtefactsAndViolations( Arrays.asList(new ViolationOccurence(firstRequirement, artefact, 12))); QualityAnalysis analysis = qualityAnalyzerService.analyzeProject(project); assertThatIsSuccessfulAndContainsOnlyGivenViolationsWithoutCostsComparison(analysis, new QualityViolation(artefact, firstRequirement, 0, 0, 12, "nloc")); }
@Test public void succeededAnalysisWithManyViolations() throws CodeChurnCalculationException, ScmConnectionEncodingException { Artefact artefactA = new Artefact("A", "A"); Artefact artefactB = new Artefact("B", "B"); Artefact artefactC = new Artefact("C", "C"); QualityAnalyzerService qualityAnalyzerService = createMockedSystemWithArtefactsAndViolations( Arrays.asList(new ViolationOccurence(firstRequirement, artefactA, 12), new ViolationOccurence(secondRequirement, artefactA, 1), new ViolationOccurence(firstRequirement, artefactB, 22), new ViolationOccurence(firstRequirement, artefactC, 45), new ViolationOccurence(secondRequirement, artefactC, 67))); QualityAnalysis analysis = qualityAnalyzerService.analyzeProject(project); assertThatIsSuccessfulAndContainsOnlyGivenViolationsWithoutCostsComparison(analysis, new QualityViolation(artefactA, firstRequirement, 0, 0, 12, "nloc"), new QualityViolation(artefactA, secondRequirement, 0, 0, 1, "nloc"), new QualityViolation(artefactB, firstRequirement, 0, 0, 22, "nloc"), new QualityViolation(artefactC, firstRequirement, 0, 0, 45, "nloc"), new QualityViolation(artefactC, secondRequirement, 0, 0, 67, "nloc")); }
@Test public void addCodeChangeProbabilityToArtefacts() throws CodeChurnCalculationException, ScmConnectionEncodingException, ResourceNotFoundException { Artefact artefactA = new Artefact("A", "A"); Artefact artefactB = new Artefact("B", "B"); ViolationOccurence violationA = new ViolationOccurence(firstRequirement, artefactA, 0); ViolationOccurence violationB = new ViolationOccurence(firstRequirement, artefactB, 0); ViolationsCalculatorService violationsCalculatorService = mock(ViolationsCalculatorService.class); when(violationsCalculatorService.calculateAllViolation(any(Project.class))) .thenReturn(ViolationsAnalysisResult.createSuccessfulAnalysis(Arrays.asList(violationA, violationB))); CodeChangeProbabilityCalculator codeChangeProbabilityCalculator = mock(CodeChangeProbabilityCalculator.class); when(codeChangeProbabilityCalculator.calculateCodeChangeProbability(any(ScmConnectionSettings.class), anyString())).thenReturn(1.2); CodeChangeProbabilityCalculatorFactory codeChangeProbabilityCalculatorFactory = createMockedCodeChangeProbabilityCalculatorFactory(); when(codeChangeProbabilityCalculatorFactory.create(any(CodeChangeSettings.class))).thenReturn(codeChangeProbabilityCalculator); QualityAnalyzerService qualityAnalyzerService = new DefaultQualityAnalyzerService(violationsCalculatorService, scmAvailabilityCheckerServiceFactory, codeChangeProbabilityCalculatorFactory, secureChangeProbabilityCalculator, costsCalculator, qualityAnalysisRepository); qualityAnalyzerService.analyzeProject(project); assertThat(artefactA.getChangeProbability()).isEqualTo(1.2); assertThat(artefactB.getChangeProbability()).isEqualTo(1.2); }
@Test public void addSecureChangeProbabilityToArtefacts() throws CodeChurnCalculationException, ScmConnectionEncodingException, ResourceNotFoundException { Artefact artefactA = new Artefact("A", "A"); Artefact artefactB = new Artefact("B", "B"); ViolationOccurence violationA = new ViolationOccurence(firstRequirement, artefactA, 0); ViolationOccurence violationB = new ViolationOccurence(firstRequirement, artefactB, 0); ViolationsCalculatorService violationsCalculatorService = mock(ViolationsCalculatorService.class); when(violationsCalculatorService.calculateAllViolation(any(Project.class))) .thenReturn(ViolationsAnalysisResult.createSuccessfulAnalysis(Arrays.asList(violationA, violationB))); CodeChangeProbabilityCalculator codeChangeProbabilityCalculator = mock(CodeChangeProbabilityCalculator.class); when(codeChangeProbabilityCalculator.calculateCodeChangeProbability(any(ScmConnectionSettings.class), anyString())).thenReturn(1.0); CodeChangeProbabilityCalculatorFactory codeChangeProbabilityCalculatorFactory = createMockedCodeChangeProbabilityCalculatorFactory(); when(codeChangeProbabilityCalculatorFactory.create(any(CodeChangeSettings.class))).thenReturn(codeChangeProbabilityCalculator); when(secureChangeProbabilityCalculator.calculateSecureChangeProbability(any(QualityProfile.class), any(SonarConnectionSettings.class), eq(artefactA))).thenReturn(1.115); when(secureChangeProbabilityCalculator.calculateSecureChangeProbability(any(QualityProfile.class), any(SonarConnectionSettings.class), eq(artefactB))).thenReturn(1.341); QualityAnalyzerService qualityAnalyzerService = new DefaultQualityAnalyzerService(violationsCalculatorService, scmAvailabilityCheckerServiceFactory, codeChangeProbabilityCalculatorFactory, secureChangeProbabilityCalculator, costsCalculator, qualityAnalysisRepository); qualityAnalyzerService.analyzeProject(project); assertThat(artefactA.getSecureChangeProbability()).isEqualTo(1.115); assertThat(artefactB.getSecureChangeProbability()).isEqualTo(1.341); }
@Test public void failedAnalysisWhenSecureChangeProbabilityCalculatorThrowsResourceNotFoundException() throws CodeChurnCalculationException, ScmConnectionEncodingException, ResourceNotFoundException { ViolationOccurence violation = new ViolationOccurence(firstRequirement, new Artefact("A", "A"), 0); ViolationsCalculatorService violationsCalculatorService = mock(ViolationsCalculatorService.class); when(violationsCalculatorService.calculateAllViolation(any(Project.class))) .thenReturn(ViolationsAnalysisResult.createSuccessfulAnalysis(Arrays.asList(violation))); CodeChangeProbabilityCalculator codeChangeProbabilityCalculator = mock(CodeChangeProbabilityCalculator.class); when(codeChangeProbabilityCalculator.calculateCodeChangeProbability(any(ScmConnectionSettings.class), anyString())).thenReturn(1.0); CodeChangeProbabilityCalculatorFactory codeChangeProbabilityCalculatorFactory = createMockedCodeChangeProbabilityCalculatorFactory(); when(codeChangeProbabilityCalculatorFactory.create(any(CodeChangeSettings.class))).thenReturn(codeChangeProbabilityCalculator); when(secureChangeProbabilityCalculator.calculateSecureChangeProbability(any(QualityProfile.class), any(SonarConnectionSettings.class), any(Artefact.class))).thenThrow(ResourceNotFoundException.class); QualityAnalyzerService qualityAnalyzerService = new DefaultQualityAnalyzerService(violationsCalculatorService, scmAvailabilityCheckerServiceFactory, codeChangeProbabilityCalculatorFactory, secureChangeProbabilityCalculator, costsCalculator, qualityAnalysisRepository); QualityAnalysis analysis = qualityAnalyzerService.analyzeProject(project); assertThat(analysis.isSuccessful()).isFalse(); }
@Test public void takeCostsFromSuppliedCostCalculator() throws CodeChurnCalculationException, ScmConnectionEncodingException, ResourceNotFoundException { ViolationOccurence violation = new ViolationOccurence(firstRequirement, new Artefact("A", "A"), 0); ViolationsCalculatorService violationsCalculatorService = mock(ViolationsCalculatorService.class); when(violationsCalculatorService.calculateAllViolation(any(Project.class))) .thenReturn(ViolationsAnalysisResult.createSuccessfulAnalysis(Arrays.asList(violation))); CodeChangeProbabilityCalculator codeChangeProbabilityCalculator = mock(CodeChangeProbabilityCalculator.class); when(codeChangeProbabilityCalculator.calculateCodeChangeProbability(any(ScmConnectionSettings.class), anyString())).thenReturn(1.0); CodeChangeProbabilityCalculatorFactory codeChangeProbabilityCalculatorFactory = createMockedCodeChangeProbabilityCalculatorFactory(); when(codeChangeProbabilityCalculatorFactory.create(any(CodeChangeSettings.class))).thenReturn(codeChangeProbabilityCalculator); QualityAnalyzerService qualityAnalyzerService = new DefaultQualityAnalyzerService(violationsCalculatorService, scmAvailabilityCheckerServiceFactory, codeChangeProbabilityCalculatorFactory, secureChangeProbabilityCalculator, costsCalculator, qualityAnalysisRepository); qualityAnalyzerService.analyzeProject(project); verify(costsCalculator).calculateRemediationCosts(project.getSonarConnectionSettings(), violation); verify(costsCalculator).calculateNonRemediationCosts(project.getSonarConnectionSettings(), violation); }
@Test public void failedAnalysisWhenViolationAnalysisWasNotSuccessful() throws CodeChurnCalculationException, ScmConnectionEncodingException { ViolationsCalculatorService violationsCalculatorService = mock(ViolationsCalculatorService.class); when(violationsCalculatorService.calculateAllViolation(any(Project.class))) .thenReturn(ViolationsAnalysisResult.createFailedAnalysis(Collections.<ViolationOccurence>emptyList(), "error")); QualityAnalyzerService qualityAnalyzerService = new DefaultQualityAnalyzerService(violationsCalculatorService, scmAvailabilityCheckerServiceFactory, mock(CodeChangeProbabilityCalculatorFactory.class), secureChangeProbabilityCalculator, costsCalculator, qualityAnalysisRepository); QualityAnalysis analysis = qualityAnalyzerService.analyzeProject(project); assertThat(analysis.isSuccessful()).isFalse(); assertThat(analysis.getFailureReason()).isEqualTo("error"); }
@Test public void failedAnalysisWhenScmSystemIsNotAvailable() { ScmAvailabilityCheckerService notAvailableScmSystem = mock(ScmAvailabilityCheckerService.class); when(notAvailableScmSystem.isAvailable(any(ScmConnectionSettings.class))).thenReturn(false); ScmAvailabilityCheckerServiceFactory notAvailableCheckerServiceFactory = mock(ScmAvailabilityCheckerServiceFactory.class); when(notAvailableCheckerServiceFactory.create(any(ScmConnectionSettings.class))).thenReturn(notAvailableScmSystem); ViolationsCalculatorService violationsCalculatorService = mock(ViolationsCalculatorService.class); when(violationsCalculatorService.calculateAllViolation(any(Project.class))) .thenReturn(ViolationsAnalysisResult.createSuccessfulAnalysis(Collections.<ViolationOccurence>emptyList())); QualityAnalyzerService qualityAnalyzerService = new DefaultQualityAnalyzerService(violationsCalculatorService, notAvailableCheckerServiceFactory, mock(CodeChangeProbabilityCalculatorFactory.class), secureChangeProbabilityCalculator, costsCalculator, qualityAnalysisRepository); QualityAnalysis analysis = qualityAnalyzerService.analyzeProject(project); assertThat(analysis.isSuccessful()).isFalse(); }
@Test public void failedAnalysisWhenProblemWithCodeChurnCalculationOccurred() throws CodeChurnCalculationException, ScmConnectionEncodingException { QualityAnalyzerService qualityAnalyzerService = createMockedSystemThatThrowsExceptionInCodeChangeCalculation(CodeChurnCalculationException.class); QualityAnalysis analysis = qualityAnalyzerService.analyzeProject(project); assertThat(analysis.isSuccessful()).isFalse(); }
@Test public void failedAnalysisWhenProblemWithScmConnectionEncodingOccurred() throws CodeChurnCalculationException, ScmConnectionEncodingException { QualityAnalyzerService qualityAnalyzerService = createMockedSystemThatThrowsExceptionInCodeChangeCalculation(ScmConnectionEncodingException.class); QualityAnalysis analysis = qualityAnalyzerService.analyzeProject(project); assertThat(analysis.isSuccessful()).isFalse(); }
@Test public void failedAnalysisWhenCostCalculatorThrowsResourceNotFoundExceptionOnRemediationCosts() throws CodeChurnCalculationException, ScmConnectionEncodingException, ResourceNotFoundException { ViolationsCalculatorService violationsCalculatorService = mock(ViolationsCalculatorService.class); when(violationsCalculatorService.calculateAllViolation(any(Project.class))) .thenReturn(ViolationsAnalysisResult.createSuccessfulAnalysis(Arrays.asList(new ViolationOccurence(firstRequirement, new Artefact("A", "A"), 0)))); CodeChangeProbabilityCalculator codeChangeProbabilityCalculator = mock(CodeChangeProbabilityCalculator.class); when(codeChangeProbabilityCalculator.calculateCodeChangeProbability(any(ScmConnectionSettings.class), anyString())).thenReturn(1.0); CodeChangeProbabilityCalculatorFactory codeChangeProbabilityCalculatorFactory = createMockedCodeChangeProbabilityCalculatorFactory(); when(codeChangeProbabilityCalculatorFactory.create(any(CodeChangeSettings.class))).thenReturn(codeChangeProbabilityCalculator); when(costsCalculator.calculateRemediationCosts(any(SonarConnectionSettings.class), any(ViolationOccurence.class))).thenThrow(ResourceNotFoundException.class); QualityAnalyzerService qualityAnalyzerService = new DefaultQualityAnalyzerService(violationsCalculatorService, scmAvailabilityCheckerServiceFactory, codeChangeProbabilityCalculatorFactory, secureChangeProbabilityCalculator, costsCalculator, qualityAnalysisRepository); QualityAnalysis analysis = qualityAnalyzerService.analyzeProject(project); assertThat(analysis.isSuccessful()).isFalse(); }
@Test public void failedAnalysisWhenCostCalculatorThrowsResourceNotFoundExceptionOnNonRemediationCosts() throws CodeChurnCalculationException, ScmConnectionEncodingException, ResourceNotFoundException { ViolationsCalculatorService violationsCalculatorService = mock(ViolationsCalculatorService.class); when(violationsCalculatorService.calculateAllViolation(any(Project.class))) .thenReturn(ViolationsAnalysisResult.createSuccessfulAnalysis(Arrays.asList(new ViolationOccurence(firstRequirement, new Artefact("A", "A"), 0)))); CodeChangeProbabilityCalculator codeChangeProbabilityCalculator = mock(CodeChangeProbabilityCalculator.class); when(codeChangeProbabilityCalculator.calculateCodeChangeProbability(any(ScmConnectionSettings.class), anyString())).thenReturn(1.0); CodeChangeProbabilityCalculatorFactory codeChangeProbabilityCalculatorFactory = createMockedCodeChangeProbabilityCalculatorFactory(); when(codeChangeProbabilityCalculatorFactory.create(any(CodeChangeSettings.class))).thenReturn(codeChangeProbabilityCalculator); when(costsCalculator.calculateNonRemediationCosts(any(SonarConnectionSettings.class), any(ViolationOccurence.class))).thenThrow(ResourceNotFoundException.class); QualityAnalyzerService qualityAnalyzerService = new DefaultQualityAnalyzerService(violationsCalculatorService, scmAvailabilityCheckerServiceFactory, codeChangeProbabilityCalculatorFactory, secureChangeProbabilityCalculator, costsCalculator, qualityAnalysisRepository); QualityAnalysis analysis = qualityAnalyzerService.analyzeProject(project); assertThat(analysis.isSuccessful()).isFalse(); } |
CodeChangeProbabilityCalculatorFactory { CodeChangeProbabilityCalculator create(CodeChangeSettings codeChangeSettings) { if (codeChangeSettings.getMethod() == SupportedCodeChangeProbabilityMethod.WEIGHTED.getId()) { return new WeightedCodeChangeProbabilityCalculator(codeChurnCalculatorFactory, LocalDate.now(), codeChangeSettings.getDays()); } else if (codeChangeSettings.getMethod() == SupportedCodeChangeProbabilityMethod.COMMIT_BASED.getId()) { return new CommitBasedCodeChangeProbabilityCalculator(codeChurnCalculatorFactory, codeChangeSettings.getNumberOfCommits()); } else { return new DefaultCodeChangeProbabilityCalculator(codeChurnCalculatorFactory, LocalDate.now(), codeChangeSettings.getDays()); } } @Autowired CodeChangeProbabilityCalculatorFactory(CodeChurnCalculatorFactory codeChurnCalculatorFactory); } | @Test public void createCalculatorForDefaultSetting() { assertThat(codeChangeProbabilityCalculatorFactory.create(CodeChangeSettings.defaultSetting(0))) .isInstanceOf(DefaultCodeChangeProbabilityCalculator.class); }
@Test public void createCalculatorWithCorrectNumberOfDaysForDefaultSetting() { assertThat(((DefaultCodeChangeProbabilityCalculator) codeChangeProbabilityCalculatorFactory.create(CodeChangeSettings.defaultSetting(30))).getDays()) .isEqualTo(30); }
@Test public void createCalculatorForWeightedSetting() { assertThat(codeChangeProbabilityCalculatorFactory.create(CodeChangeSettings.weightedSetting(0))) .isInstanceOf(WeightedCodeChangeProbabilityCalculator.class); }
@Test public void createCalculatorWithCorrectNumberOfDaysForWeightedSetting() { assertThat(((WeightedCodeChangeProbabilityCalculator) codeChangeProbabilityCalculatorFactory.create(CodeChangeSettings.weightedSetting(30))).getDays()) .isEqualTo(30); } |
SecureChangeProbabilityCalculator { public double calculateSecureChangeProbability(QualityProfile qualityProfile, SonarConnectionSettings sonarConnectionSettings, Artefact artefact) throws ResourceNotFoundException { log.info("Calculate secure change probability for artefact {}", artefact.getName()); double secureChangeProbability = 1.0; for (ChangeRiskAssessmentFunction riskAssessmentFunction : qualityProfile.getChangeRiskAssessmentFunctions()) { final double metricValueForArtefact = metricCollectorService.collectMetricForResource(sonarConnectionSettings, artefact.getSonarIdentifier(), riskAssessmentFunction.getMetricIdentifier()); secureChangeProbability += riskAssessmentFunction.getRiskChargeAmount(metricValueForArtefact); } return secureChangeProbability; } @Autowired SecureChangeProbabilityCalculator(MetricCollectorService metricCollectorService); double calculateSecureChangeProbability(QualityProfile qualityProfile, SonarConnectionSettings sonarConnectionSettings, Artefact artefact); } | @Test public void profileWithNoChangeRiskAssessmentFunctions() throws ResourceNotFoundException { assertThat(secureChangeProbabilityCalculator.calculateSecureChangeProbability( profile, mock(SonarConnectionSettings.class), mock(Artefact.class))).isEqualTo(1.0); }
@Test public void profileWithOneChangeRiskAssessmentFunction() throws ResourceNotFoundException { metricCollectorService.addMetricValue("A", "metric", 9.0); profile.addChangeRiskAssessmentFunction(new ChangeRiskAssessmentFunction(profile, "metric", Sets.newHashSet(new RiskCharge(0.2, "<", 10.0)))); assertThat(secureChangeProbabilityCalculator.calculateSecureChangeProbability( profile, mock(SonarConnectionSettings.class), artefact)).isEqualTo(1.2); }
@Test public void profileWithManyChangeRiskAssessmentFunctions() throws ResourceNotFoundException { metricCollectorService.addMetricValue("A", "metric1", 9.0); metricCollectorService.addMetricValue("A", "metric2", -1.0); metricCollectorService.addMetricValue("A", "metric3", 0.0); profile.addChangeRiskAssessmentFunction(new ChangeRiskAssessmentFunction(profile, "metric1", Sets.newHashSet(new RiskCharge(0.2, "<", 10.0)))); profile.addChangeRiskAssessmentFunction(new ChangeRiskAssessmentFunction(profile, "metric2", Sets.newHashSet(new RiskCharge(0.11, ">", -2.0)))); profile.addChangeRiskAssessmentFunction(new ChangeRiskAssessmentFunction(profile, "metric3", Sets.newHashSet(new RiskCharge(0.005, ">=", 0.0)))); assertThat(secureChangeProbabilityCalculator.calculateSecureChangeProbability( profile, mock(SonarConnectionSettings.class), artefact)).isEqualTo(1.315); } |
AnalyzerRunnable implements Runnable { @Override public void run() { Project project = projectRepository.findOne(projectId); if (project != null) { project.setHadAnalysis(true); projectRepository.save(project); log.info("Start analyzer run for project {}", project.getName()); qualityAnalyzerService.analyzeProject(project); log.info("Finished analyzer run for project {}", project.getName()); } else { log.error("Could not find project with id " + projectId + " for starting an analyzer run!"); } } AnalyzerRunnable(Project project, ProjectRepository projectRepository, QualityAnalyzerService qualityAnalyzerService); @Override void run(); } | @Test public void retrieveProjectWithRepositoryFromDatabaseAndTriggerAnalysisAfterwards() { analyzerRunnable.run(); InOrder inOrder = inOrder(projectRepository, analyzerService); inOrder.verify(projectRepository).findOne(1L); inOrder.verify(analyzerService).analyzeProject(project); inOrder.verifyNoMoreInteractions(); }
@Test public void markProjectAsHadAnalysis() { analyzerRunnable.run(); verify(project).setHadAnalysis(true); }
@Test public void executedProjectShouldBeSavedToDatabaseAfterMarkedAsHadAnalysis() { analyzerRunnable.run(); InOrder inOrder = inOrder(project, projectRepository); inOrder.verify(project).setHadAnalysis(true); inOrder.verify(projectRepository).save(project); }
@Test public void notFailWhenProjectIsNotRetrievableViaRepository() { when(projectRepository.findOne(1L)).thenReturn(null); analyzerRunnable.run(); } |
ViolationsCalculatorService { ViolationsAnalysisResult calculateAllViolation(Project project) { if (!sonarConnectionCheckerService.isReachable(project.getSonarConnectionSettings())) { return ViolationsAnalysisResult.createFailedAnalysis(Collections.<ViolationOccurence>emptyList(), "sonar project is not reachable with supplied connection settings: " + project.getSonarConnectionSettings().toString()); } log.info("Start violation analysis for project {}", project.getName()); Map<String, Artefact> artefactsThatHaveAtLeastOneViolation = Maps.newHashMap(); List<ViolationOccurence> violations = new ArrayList<ViolationOccurence>(); long violationsOfCurrentArtefact = 0; for (Resource resource : resourcesCollectorService.collectAllResourcesForProject(project.getSonarConnectionSettings())) { log.info("Analyzing resource {}", resource.getLongName()); violationsOfCurrentArtefact = 0; for (QualityRequirement qualityRequirement : project.getProfile().getRequirements()) { final double weightingMetricValue; final double metricValue; try { weightingMetricValue = metricCollectorService.collectMetricForResource(project.getSonarConnectionSettings(), resource.getKey(), qualityRequirement.getWeightingMetricIdentifier()); metricValue = metricCollectorService.collectMetricForResource(project.getSonarConnectionSettings(), resource.getKey(), qualityRequirement.getCriteria().getMetricIdentifier()); } catch (ResourceNotFoundException e) { log.warn("Quality analysis run failed due one resource or metric could not be find in Sonar!", e); return ViolationsAnalysisResult.createFailedAnalysis(violations, "resource " + resource.getKey() + " or metric " + qualityRequirement.getCriteria().getMetricIdentifier() + " not available on Sonar"); } if (qualityRequirement.isViolated(metricValue)) { final Artefact artefact; if (artefactsThatHaveAtLeastOneViolation.containsKey(resource.getKey())) { artefact = artefactsThatHaveAtLeastOneViolation.get(resource.getKey()); } else { artefact = new Artefact(resource.getLongName(), resource.getKey()); artefactsThatHaveAtLeastOneViolation.put(resource.getKey(), artefact); } log.debug("Create quality violation for artefact {} with violated requirement {}", artefact.getName(), qualityRequirement.getCriteria()); violations.add(new ViolationOccurence(qualityRequirement, artefact, weightingMetricValue)); violationsOfCurrentArtefact++; } } log.info("Found {} violations at resource {}", violationsOfCurrentArtefact, resource.getLongName()); } log.info("Successfully analysed project {} and found {} quality violations in {} artefacts", project.getName(), violations.size(), artefactsThatHaveAtLeastOneViolation.size()); return ViolationsAnalysisResult.createSuccessfulAnalysis(violations); } @Autowired ViolationsCalculatorService(SonarConnectionCheckerService sonarConnectionCheckerService,
ResourcesCollectorService resourcesCollectorService,
MetricCollectorService metricCollectorService); } | @Test public void failedViolationAnalysisResultWhenSonarProjectIsNotReachable() { SonarConnectionSettings connectionSettings = new SonarConnectionSettings(defaultSonarHost, "abc"); Project project = mock(Project.class); when(project.getSonarConnectionSettings()).thenReturn(connectionSettings); SonarConnectionCheckerService connectionCheckerService = mock(SonarConnectionCheckerService.class); when(connectionCheckerService.isReachable(any(SonarConnectionSettings.class))).thenReturn(false); ViolationsCalculatorService violationsCalculatorService = new ViolationsCalculatorService(connectionCheckerService, new ResourcesCollectorService(), new MetricCollectorService()); assertThat(violationsCalculatorService.calculateAllViolation(project).isSuccessful()).isFalse(); }
@Test public void failedViolationAnalysisResultWhenOneMetricValueIsNotReachable() throws ResourceNotFoundException { Resource dummyResource = new Resource(); ResourcesCollectorService resourcesCollectorService = mock(ResourcesCollectorService.class); when(resourcesCollectorService.collectAllResourcesForProject(any(SonarConnectionSettings.class))) .thenReturn(Arrays.asList(dummyResource)); MetricCollectorService metricCollectorService = mock(MetricCollectorService.class); when(metricCollectorService.collectMetricForResource(any(SonarConnectionSettings.class), anyString(), anyString())) .thenThrow(ResourceNotFoundException.class); ViolationsCalculatorService violationsCalculatorService = new ViolationsCalculatorService(connectionCheckerService, resourcesCollectorService, metricCollectorService); assertThat(violationsCalculatorService.calculateAllViolation(project).isSuccessful()).isFalse(); }
@Test public void noViolationsWhenNoRequirementsAreViolated() { FakeResourcesCollectorService resourcesCollectorService = new FakeResourcesCollectorService(); resourcesCollectorService.addResource("A"); resourcesCollectorService.addResource("B"); FakeMetricCollectorService metricCollectorService = new FakeMetricCollectorService(); metricCollectorService.addMetricValue("A", "cc", 11.0); metricCollectorService.addMetricValue("A", "ec", 14.0); metricCollectorService.addMetricValue("A", "nloc", 1.0); metricCollectorService.addMetricValue("B", "cc", 20.0); metricCollectorService.addMetricValue("B", "ec", 2.0); metricCollectorService.addMetricValue("B", "nloc", 1.0); ViolationsCalculatorService violationsCalculatorService = new ViolationsCalculatorService(connectionCheckerService, resourcesCollectorService, metricCollectorService); ViolationsAnalysisResult analysisResult = violationsCalculatorService.calculateAllViolation(project); assertThat(analysisResult.isSuccessful()).isTrue(); assertThat(analysisResult.getViolations()).isEmpty(); }
@Test public void violationsWhenRequirementsAreViolatedInOneArtefact() { FakeResourcesCollectorService resourcesCollectorService = new FakeResourcesCollectorService(); resourcesCollectorService.addResource("A"); resourcesCollectorService.addResource("B"); FakeMetricCollectorService metricCollectorService = new FakeMetricCollectorService(); metricCollectorService.addMetricValue("A", "cc", 11.0); metricCollectorService.addMetricValue("A", "ec", 14.0); metricCollectorService.addMetricValue("A", "nloc", 5.0); metricCollectorService.addMetricValue("B", "cc", 10.0); metricCollectorService.addMetricValue("B", "ec", 15.0); metricCollectorService.addMetricValue("B", "nloc", 50.0); ViolationsCalculatorService violationsCalculatorService = new ViolationsCalculatorService(connectionCheckerService, resourcesCollectorService, metricCollectorService); ViolationsAnalysisResult analysisResult = violationsCalculatorService.calculateAllViolation(project); assertThat(analysisResult.isSuccessful()).isTrue(); assertThat(analysisResult.getViolations()).containsOnly( new ViolationOccurence(firstRequirement, new Artefact("B", "B"), 50.0), new ViolationOccurence(secondRequirement, new Artefact("B", "B"), 50.0) ); }
@Test public void violationsWhenRequirementsAreViolatedInManyArtefact() { FakeResourcesCollectorService resourcesCollectorService = new FakeResourcesCollectorService(); resourcesCollectorService.addResource("A"); resourcesCollectorService.addResource("B"); resourcesCollectorService.addResource("C"); FakeMetricCollectorService metricCollectorService = new FakeMetricCollectorService(); metricCollectorService.addMetricValue("A", "cc", 9.0); metricCollectorService.addMetricValue("A", "ec", 20.0); metricCollectorService.addMetricValue("A", "nloc", 10.0); metricCollectorService.addMetricValue("B", "cc", 10.0); metricCollectorService.addMetricValue("B", "ec", 15.0); metricCollectorService.addMetricValue("B", "nloc", 5.0); metricCollectorService.addMetricValue("C", "cc", 11.0); metricCollectorService.addMetricValue("C", "ec", 14.0); metricCollectorService.addMetricValue("C", "nloc", 21.0); ViolationsCalculatorService violationsCalculatorService = new ViolationsCalculatorService(connectionCheckerService, resourcesCollectorService, metricCollectorService); ViolationsAnalysisResult analysisResult = violationsCalculatorService.calculateAllViolation(project); assertThat(analysisResult.isSuccessful()).isTrue(); assertThat(analysisResult.getViolations()).containsOnly( new ViolationOccurence(firstRequirement, new Artefact("A", "A"), 10.0), new ViolationOccurence(secondRequirement, new Artefact("A", "A"), 10.0), new ViolationOccurence(firstRequirement, new Artefact("B", "B"), 5.0), new ViolationOccurence(secondRequirement, new Artefact("B", "B"), 5.0) ); } |
DefaultQualityAnalyzerScheduler implements QualityAnalyzerScheduler { public boolean scheduleAnalyzer(Project project) { if (alreadyScheduledProjects.contains(project)) { log.info("Project {} is already scheduled!", project.getName()); return false; } alreadyScheduledProjects.add(project); QualityAnalyzerService qualityAnalyzerService = createDefaultQualityAnalyzer(); scheduler.schedule(new AnalyzerRunnable(project, projectRepository, qualityAnalyzerService), new CronTrigger(project.getCronExpression())); log.info("Scheduled analyzer job for project {} with cron expression {}", project.getName(), project.getCronExpression()); return true; } @Autowired DefaultQualityAnalyzerScheduler(ProjectRepository projectRepository,
ViolationsCalculatorService violationsCalculatorService,
ScmAvailabilityCheckerServiceFactory scmAvailabilityCheckerServiceFactory,
CodeChangeProbabilityCalculatorFactory codeChangeProbabilityCalculatorFactory,
SecureChangeProbabilityCalculator secureChangeProbabilityCalculator, QualityViolationCostsCalculator costsCalculator,
QualityAnalysisRepository qualityAnalysisRepository); void executeAnalyzer(Project project); boolean scheduleAnalyzer(Project project); } | @Test public void scheduleProjectForAnalysis() { assertThat(analyzerScheduler.scheduleAnalyzer(project)).isTrue(); }
@Test public void failToScheduleProjectTwice() { analyzerScheduler.scheduleAnalyzer(project); assertThat(analyzerScheduler.scheduleAnalyzer(project)).isFalse(); }
@Test public void scheduledProjectShouldNotBeMarkedAsHadAnalysis() { analyzerScheduler.scheduleAnalyzer(project); assertThat(project.hadAnalysis()).isFalse(); } |
DefaultQualityAnalyzerScheduler implements QualityAnalyzerScheduler { public void executeAnalyzer(Project project) { project.setHadAnalysis(true); projectRepository.save(project); QualityAnalyzerService qualityAnalyzerService = createDefaultQualityAnalyzer(); scheduler.execute(new AnalyzerRunnable(project, projectRepository, qualityAnalyzerService)); log.info("Executing analyzer job for project {}", project.getName()); } @Autowired DefaultQualityAnalyzerScheduler(ProjectRepository projectRepository,
ViolationsCalculatorService violationsCalculatorService,
ScmAvailabilityCheckerServiceFactory scmAvailabilityCheckerServiceFactory,
CodeChangeProbabilityCalculatorFactory codeChangeProbabilityCalculatorFactory,
SecureChangeProbabilityCalculator secureChangeProbabilityCalculator, QualityViolationCostsCalculator costsCalculator,
QualityAnalysisRepository qualityAnalysisRepository); void executeAnalyzer(Project project); boolean scheduleAnalyzer(Project project); } | @Test public void executedProjectShouldBeMarkedAsHadAnalysis() { analyzerScheduler.executeAnalyzer(project); assertThat(project.hadAnalysis()).isTrue(); }
@Test public void executedProjectShouldBeSavedToDatabaseAfterMarkedAsHadAnalysis() { analyzerScheduler.executeAnalyzer(project); InOrder inOrder = inOrder(project, projectRepository); inOrder.verify(project).setHadAnalysis(true); inOrder.verify(projectRepository).save(project); } |
QualityViolationCostsCalculator { public int calculateRemediationCosts(SonarConnectionSettings sonarConnectionSettings, ViolationOccurence violation) throws ResourceNotFoundException { log.info("Calculating remediation costs for {} with violated criteria {}", violation.getArtefact().getName(), violation.getRequirement().getCriteria()); return calculateCosts(sonarConnectionSettings, violation, violation.getRequirement().getRemediationCosts()); } @Autowired QualityViolationCostsCalculator(MetricCollectorService metricCollectorService); int calculateRemediationCosts(SonarConnectionSettings sonarConnectionSettings, ViolationOccurence violation); int calculateNonRemediationCosts(SonarConnectionSettings sonarConnectionSettings, ViolationOccurence violation); } | @Test public void calculateRemediationCostsProperlyForGreaterOperator() throws ResourceNotFoundException { QualityRequirement requirement = new QualityRequirement(qualityProfile, 20, 30, 100, "nloc", new QualityCriteria("metric", ">", 10.0)); ViolationOccurence violation = new ViolationOccurence(requirement, artefact, 0); assertThat(costsCalculator.calculateRemediationCosts(connectionSettings, violation)).isEqualTo(216); }
@Test public void calculateRemediationCostsProperlyForLessOperator() throws ResourceNotFoundException { QualityRequirement requirement = new QualityRequirement(qualityProfile, 20, 30, 100, "nloc", new QualityCriteria("metric", "<", 1.0)); ViolationOccurence violation = new ViolationOccurence(requirement, artefact, 0); assertThat(costsCalculator.calculateRemediationCosts(connectionSettings, violation)).isEqualTo(48); } |
QualityViolationCostsCalculator { public int calculateNonRemediationCosts(SonarConnectionSettings sonarConnectionSettings, ViolationOccurence violation) throws ResourceNotFoundException { log.info("Calculating non-remediation costs for {} with violated criteria {}", violation.getArtefact().getName(), violation.getRequirement().getCriteria()); return calculateCosts(sonarConnectionSettings, violation, violation.getRequirement().getNonRemediationCosts()); } @Autowired QualityViolationCostsCalculator(MetricCollectorService metricCollectorService); int calculateRemediationCosts(SonarConnectionSettings sonarConnectionSettings, ViolationOccurence violation); int calculateNonRemediationCosts(SonarConnectionSettings sonarConnectionSettings, ViolationOccurence violation); } | @Test public void calculateNonRemediationCostsProperlyForGreaterEqualsOperator() throws ResourceNotFoundException { QualityRequirement requirement = new QualityRequirement(qualityProfile, 20, 30, 100, "nloc", new QualityCriteria("metric", ">=", 5.0)); ViolationOccurence violation = new ViolationOccurence(requirement, artefact, 0); assertThat(costsCalculator.calculateNonRemediationCosts(connectionSettings, violation)).isEqualTo(108); } |
Artefact implements Serializable { public String getFilename() { if (name.isEmpty()) { return ""; } return name.replace('.', '/') + ".java"; } protected Artefact(); Artefact(String name, String sonarIdentifier); String getFilename(); String getShortClassName(); boolean hasManualEstimate(); } | @Test public void shouldConvertPackageNameToFilenameProperly() { assertThat(new Artefact("org.my.class.AbcDe", "").getFilename()).isEqualTo("org/my/class/AbcDe.java"); }
@Test public void shouldConvertClassNameToFilenameProperly() { assertThat(new Artefact("AbcDe", "").getFilename()).isEqualTo("AbcDe.java"); }
@Test public void shouldConvertEmptyPackageNameToFilenameProperly() { assertThat(new Artefact("", "").getFilename()).isEqualTo(""); } |
Artefact implements Serializable { public String getShortClassName() { String className = null; for (String packageName : Splitter.on('.').split(name)) { className = packageName; } return className; } protected Artefact(); Artefact(String name, String sonarIdentifier); String getFilename(); String getShortClassName(); boolean hasManualEstimate(); } | @Test public void shouldConvertFullyQualifiedClassNameToShortClassName() { assertThat(new Artefact("org.util.MyClass", "").getShortClassName()).isEqualTo("MyClass"); }
@Test public void shouldConvertFullyQualifiedClassNameWithoutPackagesToShortClassName() { assertThat(new Artefact("Class123", "").getShortClassName()).isEqualTo("Class123"); }
@Test public void shouldConvertEmptyFullyQualifiedClassNameToShortClassName() { assertThat(new Artefact("", "").getShortClassName()).isEqualTo(""); } |
QualityAnalyzerRunsSchedulerOnStartup implements ApplicationListener<ContextRefreshedEvent> { @Override public void onApplicationEvent(ContextRefreshedEvent event) { if (alreadyExecuted.compareAndSet(false, true)) { List<Project> projects = projectRepository.findAll(); log.info("Schedule analyzer jobs for {} projects", projects.size()); for (Project project : projects) { analyzerScheduler.scheduleAnalyzer(project); } } else { log.info("Projects already scheduled."); } } @Autowired QualityAnalyzerRunsSchedulerOnStartup(QualityAnalyzerScheduler analyzerScheduler, ProjectRepository projectRepository); @Override void onApplicationEvent(ContextRefreshedEvent event); } | @Test public void scheduleAllProjects() { analyzerRunsSchedulerOnStartup.onApplicationEvent(null); verify(analyzerScheduler).scheduleAnalyzer(projectA); verify(analyzerScheduler).scheduleAnalyzer(projectB); verify(analyzerScheduler).scheduleAnalyzer(projectC); }
@Test public void preventSchedulingProjectsTwice() { analyzerRunsSchedulerOnStartup.onApplicationEvent(null); analyzerRunsSchedulerOnStartup.onApplicationEvent(null); verify(analyzerScheduler, times(1)).scheduleAnalyzer(projectA); verify(analyzerScheduler, times(1)).scheduleAnalyzer(projectB); verify(analyzerScheduler, times(1)).scheduleAnalyzer(projectC); } |
SonarServerValidator implements Validator { @Override public boolean supports(Class<?> clazz) { return SonarServer.class.equals(clazz); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); } | @Test public void shouldSupportSonarServerType() { assertThat(validator.supports(SonarServer.class)).isTrue(); }
@Test public void shouldNotSupportOtherTypeThanSonarServer() { assertThat(validator.supports(Object.class)).isFalse(); } |
RoiDistributionFilter { Collection<RoiDistribution> filterHighestRoi(Collection<RoiDistribution> roiDistributions, int numberOfBestElements) { Map<Integer, RoiDistribution> filteredRoiDistributionsByInvest = Maps.newHashMap(); for (RoiDistribution distribution : roiDistributions) { filteredRoiDistributionsByInvest.put(distribution.getInvestInMinutes(), new RoiDistribution(distribution.getInvestInMinutes(), new HashMap<String, Integer>())); } for (String artefact : findArtefactsWithHighestRoi(roiDistributions, numberOfBestElements)) { for (RoiDistribution distribution : roiDistributions) { Integer roi = distribution.getRoiByArtefact().get(artefact); filteredRoiDistributionsByInvest.get(distribution.getInvestInMinutes()).getRoiByArtefact().put(artefact, roi); } } return filteredRoiDistributionsByInvest.values(); } } | @Test public void filterCorrectNumberOfBestRois() { Map<String, Integer> roiByArtefact = Maps.newHashMap(); roiByArtefact.put("A", 10); roiByArtefact.put("B", 10); roiByArtefact.put("C", 10); List<RoiDistribution> roiDistribution = Arrays.asList(new RoiDistribution(0, roiByArtefact)); assertThat(roiDistributionFilter.filterHighestRoi(roiDistribution, 2).iterator().next().getRoiByArtefact().keySet()).containsOnly("A", "B"); }
@Test public void notFailWhenNumberOfArtefactsToFilterIsBiggerThanActualArtefacts() { Map<String, Integer> roiByArtefact = Maps.newHashMap(); roiByArtefact.put("A", 10); List<RoiDistribution> roiDistribution = Arrays.asList(new RoiDistribution(0, roiByArtefact)); assertThat(roiDistributionFilter.filterHighestRoi(roiDistribution, 2).iterator().next().getRoiByArtefact().keySet()).containsOnly("A"); }
@Test public void filterBestRoisFromOneDistribution() { Map<String, Integer> roiByArtefact = Maps.newHashMap(); roiByArtefact.put("A", 10); roiByArtefact.put("B", 11); roiByArtefact.put("C", 9); roiByArtefact.put("D", 12); List<RoiDistribution> roiDistribution = Arrays.asList(new RoiDistribution(0, roiByArtefact)); assertThat(roiDistributionFilter.filterHighestRoi(roiDistribution, 3).iterator().next().getRoiByArtefact().keySet()).containsOnly("A", "B", "D"); }
@Test public void filterBestRoisFromManyDistributions() { Map<String, Integer> roiByArtefactOneInvest = Maps.newHashMap(); roiByArtefactOneInvest.put("A", 10); roiByArtefactOneInvest.put("B", 1); roiByArtefactOneInvest.put("C", 2); roiByArtefactOneInvest.put("D", 9); roiByArtefactOneInvest.put("E", 8); Map<String, Integer> roiByArtefactForTwoInvest = Maps.newHashMap(); roiByArtefactForTwoInvest.put("A", 2); roiByArtefactForTwoInvest.put("B", 10); roiByArtefactForTwoInvest.put("C", 4); roiByArtefactForTwoInvest.put("D", 3); roiByArtefactForTwoInvest.put("E", 1); Map<String, Integer> roiByArtefactForThreeInvest = Maps.newHashMap(); roiByArtefactForThreeInvest.put("A", 1); roiByArtefactForThreeInvest.put("B", 2); roiByArtefactForThreeInvest.put("C", 3); roiByArtefactForThreeInvest.put("D", 4); roiByArtefactForThreeInvest.put("E", 10); List<RoiDistribution> roiDistributions = Arrays.asList( new RoiDistribution(1, roiByArtefactOneInvest), new RoiDistribution(2, roiByArtefactForTwoInvest), new RoiDistribution(3, roiByArtefactForThreeInvest)); List<RoiDistribution> distributions = Lists.newArrayList(roiDistributionFilter.filterHighestRoi(roiDistributions, 4)); assertThat(distributions).hasSize(3); assertThat(distributions.get(0).getRoiByArtefact().keySet()).containsOnly("A", "B", "D", "E"); } |
SonarConnectionSettingsValidator implements Validator { @Override public boolean supports(Class<?> clazz) { return SonarConnectionSettings.class.equals(clazz); } @Override boolean supports(Class<?> clazz); @Override void validate(Object target, Errors errors); } | @Test public void shouldSupportSonarConnectionSettingsType() { assertThat(validator.supports(SonarConnectionSettings.class)).isTrue(); }
@Test public void shouldNotSupportOtherTypeThanSonarConnectionSettings() { assertThat(validator.supports(Object.class)).isFalse(); } |
ThriftyConverterFactory extends Converter.Factory { public static ThriftyConverterFactory create(ProtocolType protocolType) { return new ThriftyConverterFactory(protocolType); } private ThriftyConverterFactory(ProtocolType protocolType); static ThriftyConverterFactory create(ProtocolType protocolType); @Override @SuppressWarnings("unchecked") Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit); @Override @SuppressWarnings("unchecked") Converter<?, RequestBody> requestBodyConverter(Type type,
Annotation[] parameterAnnotations,
Annotation[] methodAnnotations,
Retrofit retrofit); } | @Test public void generatedClassWithoutAdapter() throws IOException { Retrofit retrofit = new Retrofit.Builder() .baseUrl(server.url("/")) .addConverterFactory(ThriftyConverterFactory.create(ProtocolType.BINARY)) .build(); BrokenService brokenService = retrofit.create(BrokenService.class); try { brokenService.get(); fail(); } catch (IllegalArgumentException ignored) { } } |
Angles { public void setSensorOffset(@NonNull Facing sensorFacing, int sensorOffset) { sanitizeInput(sensorOffset); mSensorFacing = sensorFacing; mSensorOffset = sensorOffset; if (mSensorFacing == Facing.FRONT) { mSensorOffset = sanitizeOutput(360 - mSensorOffset); } print(); } void setSensorOffset(@NonNull Facing sensorFacing, int sensorOffset); void setDisplayOffset(int displayOffset); void setDeviceOrientation(int deviceOrientation); int offset(@NonNull Reference from, @NonNull Reference to, @NonNull Axis axis); boolean flip(@NonNull Reference from, @NonNull Reference to); } | @Test public void testSetSensorOffset() { angles.setSensorOffset(Facing.BACK, 90); assertEquals(90, angles.mSensorOffset); angles.setSensorOffset(Facing.FRONT, 90); assertEquals(270, angles.mSensorOffset); }
@Test(expected = IllegalStateException.class) public void testSetSensorOffset_throws() { angles.setSensorOffset(Facing.BACK, 135); } |
Pool { @NonNull @Override public String toString() { return getClass().getSimpleName() + " - count:" + count() + ", active:" + activeCount() + ", recycled:" + recycledCount(); } Pool(int maxPoolSize, @NonNull Factory<T> factory); boolean isEmpty(); @Nullable T get(); void recycle(@NonNull T item); @CallSuper void clear(); final int count(); @SuppressWarnings("WeakerAccess") final int activeCount(); @SuppressWarnings("WeakerAccess") final int recycledCount(); @NonNull @Override String toString(); } | @Test public void testToString() { String string = pool.toString(); assertTrue(string.contains("count")); assertTrue(string.contains("active")); assertTrue(string.contains("recycled")); assertTrue(string.contains(Pool.class.getSimpleName())); } |
Pool { public void recycle(@NonNull T item) { synchronized (lock) { LOG.v("RECYCLE - Recycling item.", this); if (--activeCount < 0) { throw new IllegalStateException("Trying to recycle an item which makes " + "activeCount < 0. This means that this or some previous items being " + "recycled were not coming from this pool, or some item was recycled " + "more than once. " + this); } if (!queue.offer(item)) { throw new IllegalStateException("Trying to recycle an item while the queue " + "is full. This means that this or some previous items being recycled " + "were not coming from this pool, or some item was recycled " + "more than once. " + this); } } } Pool(int maxPoolSize, @NonNull Factory<T> factory); boolean isEmpty(); @Nullable T get(); void recycle(@NonNull T item); @CallSuper void clear(); final int count(); @SuppressWarnings("WeakerAccess") final int activeCount(); @SuppressWarnings("WeakerAccess") final int recycledCount(); @NonNull @Override String toString(); } | @Test(expected = IllegalStateException.class) public void testRecycle_notActive() { Item item = new Item(); pool.recycle(item); } |
Pool { @Nullable public T get() { synchronized (lock) { T item = queue.poll(); if (item != null) { activeCount++; LOG.v("GET - Reusing recycled item.", this); return item; } if (isEmpty()) { LOG.v("GET - Returning null. Too much items requested.", this); return null; } activeCount++; LOG.v("GET - Creating a new item.", this); return factory.create(); } } Pool(int maxPoolSize, @NonNull Factory<T> factory); boolean isEmpty(); @Nullable T get(); void recycle(@NonNull T item); @CallSuper void clear(); final int count(); @SuppressWarnings("WeakerAccess") final int activeCount(); @SuppressWarnings("WeakerAccess") final int recycledCount(); @NonNull @Override String toString(); } | @Test public void testGet_fromFactory() { pool.get(); assertEquals(1, instances); }
@Test public void testGet_whenFull() { for (int i = 0; i < MAX_SIZE; i++) { pool.get(); } assertNull(pool.get()); }
@Test public void testInstances() { for (int i = 0; i < MAX_SIZE; i++) { assertEquals(instances, i); pool.get(); } } |
Frame { @Override public boolean equals(Object obj) { return obj instanceof Frame && ((Frame) obj).mTime == mTime; } Frame(@NonNull FrameManager manager); @Override boolean equals(Object obj); @SuppressLint("NewApi") @NonNull Frame freeze(); void release(); @SuppressWarnings("unchecked") @NonNull T getData(); @NonNull Class<?> getDataClass(); long getTime(); @Deprecated int getRotation(); int getRotationToUser(); int getRotationToView(); @NonNull Size getSize(); int getFormat(); } | @Test public void testEquals() { Frame f1 = new Frame(manager); long time = 1000; f1.setContent("foo", time, 90, 180, new Size(5, 5), ImageFormat.NV21); Frame f2 = new Frame(manager); f2.setContent("bar", time, 0, 90, new Size(10, 10), ImageFormat.NV21); assertEquals(f1, f2); f2.setContent("foo", time + 1, 0, 90, new Size(10, 10), ImageFormat.NV21); assertNotEquals(f1, f2); } |
Frame { @SuppressLint("NewApi") @NonNull public Frame freeze() { ensureHasContent(); Frame other = new Frame(mManager); Object data = mManager.cloneFrameData(getData()); other.setContent(data, mTime, mUserRotation, mViewRotation, mSize, mFormat); return other; } Frame(@NonNull FrameManager manager); @Override boolean equals(Object obj); @SuppressLint("NewApi") @NonNull Frame freeze(); void release(); @SuppressWarnings("unchecked") @NonNull T getData(); @NonNull Class<?> getDataClass(); long getTime(); @Deprecated int getRotation(); int getRotationToUser(); int getRotationToView(); @NonNull Size getSize(); int getFormat(); } | @Test public void testFreeze() { Frame frame = new Frame(manager); String data = "test data"; long time = 1000; int userRotation = 90; int viewRotation = 90; Size size = new Size(10, 10); int format = ImageFormat.NV21; frame.setContent(data, time, userRotation, viewRotation, size, format); Frame frozen = frame.freeze(); assertEquals(data, frozen.getData()); assertEquals(time, frozen.getTime()); assertEquals(userRotation, frozen.getRotationToUser()); assertEquals(viewRotation, frozen.getRotationToView()); assertEquals(size, frozen.getSize()); frame.setContent("new data", 50, 180, 180, new Size(1, 1), ImageFormat.JPEG); assertEquals(data, frozen.getData()); assertEquals(time, frozen.getTime()); assertEquals(userRotation, frozen.getRotationToUser()); assertEquals(viewRotation, frozen.getRotationToView()); assertEquals(size, frozen.getSize()); assertEquals(format, frozen.getFormat()); } |
AspectRatio implements Comparable<AspectRatio> { @Override public boolean equals(Object o) { if (o == null) { return false; } if (this == o) { return true; } if (o instanceof AspectRatio) { return toFloat() == ((AspectRatio) o).toFloat(); } return false; } private AspectRatio(int x, int y); @NonNull static AspectRatio of(@NonNull Size size); @NonNull static AspectRatio of(int x, int y); @NonNull @SuppressWarnings("WeakerAccess") static AspectRatio parse(@NonNull String string); int getX(); int getY(); boolean matches(@NonNull Size size); boolean matches(@NonNull Size size, float tolerance); @Override boolean equals(Object o); @NonNull @Override String toString(); float toFloat(); @Override int hashCode(); @Override int compareTo(@NonNull AspectRatio another); @SuppressWarnings("SuspiciousNameCombination") @NonNull AspectRatio flip(); } | @Test public void testEquals() { AspectRatio ratio = AspectRatio.of(50, 10); assertNotNull(ratio); assertEquals(ratio, ratio); AspectRatio ratio1 = AspectRatio.of(5, 1); assertEquals(ratio, ratio1); AspectRatio.sCache.clear(); AspectRatio ratio2 = AspectRatio.of(500, 100); assertEquals(ratio, ratio2); Size size = new Size(500, 100); assertTrue(ratio.matches(size)); } |
AspectRatio implements Comparable<AspectRatio> { @NonNull @SuppressWarnings("WeakerAccess") public static AspectRatio parse(@NonNull String string) { String[] parts = string.split(":"); if (parts.length != 2) { throw new NumberFormatException("Illegal AspectRatio string. Must be x:y"); } int x = Integer.parseInt(parts[0]); int y = Integer.parseInt(parts[1]); return of(x, y); } private AspectRatio(int x, int y); @NonNull static AspectRatio of(@NonNull Size size); @NonNull static AspectRatio of(int x, int y); @NonNull @SuppressWarnings("WeakerAccess") static AspectRatio parse(@NonNull String string); int getX(); int getY(); boolean matches(@NonNull Size size); boolean matches(@NonNull Size size, float tolerance); @Override boolean equals(Object o); @NonNull @Override String toString(); float toFloat(); @Override int hashCode(); @Override int compareTo(@NonNull AspectRatio another); @SuppressWarnings("SuspiciousNameCombination") @NonNull AspectRatio flip(); } | @Test(expected = NumberFormatException.class) public void testParse_notNumbers() { AspectRatio.parse("a:b"); }
@Test(expected = NumberFormatException.class) public void testParse_noColon() { AspectRatio.parse("24"); }
@Test public void testParse() { AspectRatio ratio = AspectRatio.parse("16:9"); assertEquals(ratio.getX(), 16); assertEquals(ratio.getY(), 9); } |
Angles { public void setDisplayOffset(int displayOffset) { sanitizeInput(displayOffset); mDisplayOffset = displayOffset; print(); } void setSensorOffset(@NonNull Facing sensorFacing, int sensorOffset); void setDisplayOffset(int displayOffset); void setDeviceOrientation(int deviceOrientation); int offset(@NonNull Reference from, @NonNull Reference to, @NonNull Axis axis); boolean flip(@NonNull Reference from, @NonNull Reference to); } | @Test public void testSetDisplayOffset() { angles.setDisplayOffset(90); assertEquals(90, angles.mDisplayOffset); }
@Test(expected = IllegalStateException.class) public void testSetDisplayOffset_throws() { angles.setDisplayOffset(135); } |
Size implements Comparable<Size> { @SuppressWarnings("SuspiciousNameCombination") public Size flip() { return new Size(mHeight, mWidth); } Size(int width, int height); int getWidth(); int getHeight(); @SuppressWarnings("SuspiciousNameCombination") Size flip(); @Override boolean equals(Object o); @NonNull @Override String toString(); @Override int hashCode(); @Override int compareTo(@NonNull Size another); } | @Test public void testFlip() { Size size = new Size(10, 20); Size flipped = size.flip(); assertEquals(size.getWidth(), flipped.getHeight()); assertEquals(size.getHeight(), flipped.getWidth()); } |
Size implements Comparable<Size> { @Override public boolean equals(Object o) { if (o == null) { return false; } if (this == o) { return true; } if (o instanceof Size) { Size size = (Size) o; return mWidth == size.mWidth && mHeight == size.mHeight; } return false; } Size(int width, int height); int getWidth(); int getHeight(); @SuppressWarnings("SuspiciousNameCombination") Size flip(); @Override boolean equals(Object o); @NonNull @Override String toString(); @Override int hashCode(); @Override int compareTo(@NonNull Size another); } | @Test public void testEquals() { Size s1 = new Size(10, 20); assertEquals(s1, s1); assertNotEquals(s1, null); assertNotEquals(s1, ""); Size s2 = new Size(10, 0); Size s3 = new Size(10, 20); assertEquals(s1, s3); assertNotEquals(s1, s2); } |
Size implements Comparable<Size> { @Override public int hashCode() { return mHeight ^ ((mWidth << (Integer.SIZE / 2)) | (mWidth >>> (Integer.SIZE / 2))); } Size(int width, int height); int getWidth(); int getHeight(); @SuppressWarnings("SuspiciousNameCombination") Size flip(); @Override boolean equals(Object o); @NonNull @Override String toString(); @Override int hashCode(); @Override int compareTo(@NonNull Size another); } | @Test public void testHashCode() { Size s1 = new Size(10, 20); Size s2 = new Size(10, 0); assertNotEquals(s1.hashCode(), s2.hashCode()); } |
Size implements Comparable<Size> { @Override public int compareTo(@NonNull Size another) { return mWidth * mHeight - another.mWidth * another.mHeight; } Size(int width, int height); int getWidth(); int getHeight(); @SuppressWarnings("SuspiciousNameCombination") Size flip(); @Override boolean equals(Object o); @NonNull @Override String toString(); @Override int hashCode(); @Override int compareTo(@NonNull Size another); } | @Test public void testCompare() { Size s1 = new Size(10, 20); Size s2 = new Size(10, 0); Size s3 = new Size(10, 20); assertTrue(s1.compareTo(s3) == 0); assertTrue(s1.compareTo(s2) > 0); assertTrue(s2.compareTo(s1) < 0); } |
SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector withFilter(@NonNull Filter filter) { return new FilterSelector(filter); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); } | @Test public void testWithFilter() { SizeSelector selector = SizeSelectors.withFilter(new SizeSelectors.Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getWidth() == 600; } }); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(600, 900)); assertEquals(list.get(1), new Size(600, 600)); } |
SizeSelectors { @NonNull public static SizeSelector maxWidth(final int width) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getWidth() <= width; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); } | @Test public void testMaxWidth() { SizeSelector selector = SizeSelectors.maxWidth(50); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(30, 40)); assertEquals(list.get(1), new Size(40, 30)); } |
SizeSelectors { @NonNull public static SizeSelector minWidth(final int width) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getWidth() >= width; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); } | @Test public void testMinWidth() { SizeSelector selector = SizeSelectors.minWidth(1000); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(1600, 900)); assertEquals(list.get(1), new Size(2000, 4000)); } |
SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector maxHeight(final int height) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getHeight() <= height; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); } | @Test public void testMaxHeight() { SizeSelector selector = SizeSelectors.maxHeight(50); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(30, 40)); assertEquals(list.get(1), new Size(40, 30)); } |
SizeSelectors { @NonNull public static SizeSelector minHeight(final int height) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getHeight() >= height; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); } | @Test public void testMinHeight() { SizeSelector selector = SizeSelectors.minHeight(1000); List<Size> list = selector.select(input); assertEquals(list.size(), 1); assertEquals(list.get(0), new Size(2000, 4000)); } |
SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector aspectRatio(AspectRatio ratio, final float delta) { final float desired = ratio.toFloat(); return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { float candidate = AspectRatio.of(size.getWidth(), size.getHeight()).toFloat(); return candidate >= desired - delta && candidate <= desired + delta; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); } | @Test public void testAspectRatio() { SizeSelector selector = SizeSelectors.aspectRatio(AspectRatio.of(16, 9), 0); List<Size> list = selector.select(input); assertEquals(list.size(), 1); assertEquals(list.get(0), new Size(1600, 900)); selector = SizeSelectors.aspectRatio(AspectRatio.of(1, 2), 0); list = selector.select(input); assertEquals(list.size(), 3); assertEquals(list.get(0), new Size(100, 200)); assertEquals(list.get(1), new Size(150, 300)); assertEquals(list.get(2), new Size(2000, 4000)); } |
Angles { public void setDeviceOrientation(int deviceOrientation) { sanitizeInput(deviceOrientation); mDeviceOrientation = deviceOrientation; print(); } void setSensorOffset(@NonNull Facing sensorFacing, int sensorOffset); void setDisplayOffset(int displayOffset); void setDeviceOrientation(int deviceOrientation); int offset(@NonNull Reference from, @NonNull Reference to, @NonNull Axis axis); boolean flip(@NonNull Reference from, @NonNull Reference to); } | @Test public void testSetDeviceOrientation() { angles.setDeviceOrientation(90); assertEquals(90, angles.mDeviceOrientation); }
@Test(expected = IllegalStateException.class) public void testSetDeviceOrientation_throws() { angles.setDeviceOrientation(135); } |
SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector biggest() { return new SizeSelector() { @NonNull @Override public List<Size> select(@NonNull List<Size> source) { Collections.sort(source); Collections.reverse(source); return source; } }; } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); } | @Test public void testMax() { SizeSelector selector = SizeSelectors.biggest(); List<Size> list = selector.select(input); assertEquals(list.size(), input.size()); assertEquals(list.get(0), new Size(2000, 4000)); } |
SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector smallest() { return new SizeSelector() { @NonNull @Override public List<Size> select(@NonNull List<Size> source) { Collections.sort(source); return source; } }; } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); } | @Test public void testMin() { SizeSelector selector = SizeSelectors.smallest(); List<Size> list = selector.select(input); assertEquals(list.size(), input.size()); assertTrue(list.get(0).equals(new Size(30, 40)) || list.get(0).equals(new Size(40, 30))); } |
SizeSelectors { @NonNull @SuppressWarnings("WeakerAccess") public static SizeSelector maxArea(final int area) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getHeight() * size.getWidth() <= area; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); } | @Test public void testMaxArea() { SizeSelector selector = SizeSelectors.maxArea(100 * 100); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(30, 40)); assertEquals(list.get(1), new Size(40, 30)); } |
SizeSelectors { @SuppressWarnings("WeakerAccess") @NonNull public static SizeSelector minArea(final int area) { return withFilter(new Filter() { @Override public boolean accepts(@NonNull Size size) { return size.getHeight() * size.getWidth() >= area; } }); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); } | @Test public void testMinArea() { SizeSelector selector = SizeSelectors.minArea(1000 * 1000); List<Size> list = selector.select(input); assertEquals(list.size(), 2); assertEquals(list.get(0), new Size(1600, 900)); assertEquals(list.get(1), new Size(2000, 4000)); } |
SizeSelectors { @NonNull public static SizeSelector and(SizeSelector... selectors) { return new AndSelector(selectors); } @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector withFilter(@NonNull Filter filter); @NonNull static SizeSelector maxWidth(final int width); @NonNull static SizeSelector minWidth(final int width); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector maxHeight(final int height); @NonNull static SizeSelector minHeight(final int height); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector aspectRatio(AspectRatio ratio, final float delta); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector biggest(); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector smallest(); @NonNull @SuppressWarnings("WeakerAccess") static SizeSelector maxArea(final int area); @SuppressWarnings("WeakerAccess") @NonNull static SizeSelector minArea(final int area); @NonNull static SizeSelector and(SizeSelector... selectors); @NonNull static SizeSelector or(SizeSelector... selectors); } | @Test public void testAnd() { SizeSelector selector = SizeSelectors.and( SizeSelectors.aspectRatio(AspectRatio.of(1, 2), 0), SizeSelectors.maxWidth(100) ); List<Size> list = selector.select(input); assertEquals(list.size(), 1); assertEquals(list.get(0), new Size(100, 200)); } |
ExifHelper { public static int getOrientation(int exifOrientation) { int orientation; switch (exifOrientation) { case ExifInterface.ORIENTATION_NORMAL: case ExifInterface.ORIENTATION_FLIP_HORIZONTAL: orientation = 0; break; case ExifInterface.ORIENTATION_ROTATE_180: case ExifInterface.ORIENTATION_FLIP_VERTICAL: orientation = 180; break; case ExifInterface.ORIENTATION_ROTATE_90: case ExifInterface.ORIENTATION_TRANSPOSE: orientation = 90; break; case ExifInterface.ORIENTATION_ROTATE_270: case ExifInterface.ORIENTATION_TRANSVERSE: orientation = 270; break; default: orientation = 0; } return orientation; } static int getOrientation(int exifOrientation); static int getExifOrientation(int orientation); } | @Test public void testValues() { assertEquals(0, ExifHelper.getOrientation(ExifInterface.ORIENTATION_NORMAL)); assertEquals(0, ExifHelper.getOrientation(ExifInterface.ORIENTATION_FLIP_HORIZONTAL)); assertEquals(180, ExifHelper.getOrientation(ExifInterface.ORIENTATION_ROTATE_180)); assertEquals(180, ExifHelper.getOrientation(ExifInterface.ORIENTATION_FLIP_VERTICAL)); assertEquals(90, ExifHelper.getOrientation(ExifInterface.ORIENTATION_ROTATE_90)); assertEquals(90, ExifHelper.getOrientation(ExifInterface.ORIENTATION_TRANSPOSE)); assertEquals(270, ExifHelper.getOrientation(ExifInterface.ORIENTATION_ROTATE_270)); assertEquals(270, ExifHelper.getOrientation(ExifInterface.ORIENTATION_TRANSVERSE)); }
@Test public void testUnknownValues() { assertEquals(0, ExifHelper.getOrientation(-15)); assertEquals(0, ExifHelper.getOrientation(-1)); assertEquals(0, ExifHelper.getOrientation(195)); assertEquals(0, ExifHelper.getOrientation(Integer.MAX_VALUE)); } |
Pool { @CallSuper public void clear() { synchronized (lock) { queue.clear(); } } Pool(int maxPoolSize, @NonNull Factory<T> factory); boolean isEmpty(); @Nullable T get(); void recycle(@NonNull T item); @CallSuper void clear(); final int count(); @SuppressWarnings("WeakerAccess") final int activeCount(); @SuppressWarnings("WeakerAccess") final int recycledCount(); @NonNull @Override String toString(); } | @Test public void testClear() { Item item = pool.get(); assertNotNull(item); pool.recycle(item); assertEquals(pool.recycledCount(), 1); assertEquals(pool.activeCount(), 0); assertEquals(pool.count(), 1); pool.clear(); assertEquals(pool.recycledCount(), 0); assertEquals(pool.activeCount(), 0); assertEquals(pool.count(), 0); } |
SchedulingStrategies { public static SchedulingStrategy createInvokerStrategy( ConsoleLogger logger ) { return new InvokerStrategy( logger ); } static SchedulingStrategy createInvokerStrategy( ConsoleLogger logger ); static SchedulingStrategy createParallelStrategy( ConsoleLogger logger, int nThreads ); static SchedulingStrategy createParallelStrategyUnbounded( ConsoleLogger logger ); static SchedulingStrategy createParallelSharedStrategy( ConsoleLogger logger, ExecutorService threadPool ); } | @Test public void invokerStrategy() throws InterruptedException { SchedulingStrategy strategy = SchedulingStrategies.createInvokerStrategy( new Logger() ); assertFalse( strategy.hasSharedThreadPool() ); assertTrue( strategy.canSchedule() ); Task task = new Task(); strategy.schedule( task ); assertTrue( strategy.canSchedule() ); assertTrue( task.result ); assertTrue( strategy.finished() ); assertFalse( strategy.canSchedule() ); } |
JUnitCoreParameters { public boolean isParallelOptimization() { return parallelOptimization; } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; } | @Test public void optimizationParameter() { assertFalse( newTestSetOptimization( false ).isParallelOptimization() ); } |
JUnitCoreParameters { public boolean isParallelMethods() { return isAllParallel() || lowerCase( "both", "methods", "suitesAndMethods", "classesAndMethods" ).contains( parallel ); } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; } | @Test public void isParallelMethod() { assertFalse( newTestSetClasses().isParallelMethods() ); assertTrue( newTestSetMethods().isParallelMethods() ); assertTrue( newTestSetBoth().isParallelMethods() ); } |
JUnitCoreParameters { public boolean isParallelClasses() { return isAllParallel() || lowerCase( "both", "classes", "suitesAndClasses", "classesAndMethods" ).contains( parallel ); } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; } | @Test public void isParallelClasses() { assertTrue( newTestSetClasses().isParallelClasses() ); assertFalse( newTestSetMethods().isParallelClasses() ); assertTrue( newTestSetBoth().isParallelClasses() ); } |
JUnitCoreParameters { @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) public boolean isParallelBoth() { return isParallelMethods() && isParallelClasses(); } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; } | @Test public void isParallelBoth() { assertFalse( isParallelMethodsAndClasses( newTestSetClasses() ) ); assertFalse( isParallelMethodsAndClasses( newTestSetMethods() ) ); assertTrue( isParallelMethodsAndClasses( newTestSetBoth() ) ); } |
SchedulingStrategies { public static SchedulingStrategy createParallelStrategy( ConsoleLogger logger, int nThreads ) { return new NonSharedThreadPoolStrategy( logger, Executors.newFixedThreadPool( nThreads, DAEMON_THREAD_FACTORY ) ); } static SchedulingStrategy createInvokerStrategy( ConsoleLogger logger ); static SchedulingStrategy createParallelStrategy( ConsoleLogger logger, int nThreads ); static SchedulingStrategy createParallelStrategyUnbounded( ConsoleLogger logger ); static SchedulingStrategy createParallelSharedStrategy( ConsoleLogger logger, ExecutorService threadPool ); } | @Test public void nonSharedPoolStrategy() throws InterruptedException { SchedulingStrategy strategy = SchedulingStrategies.createParallelStrategy( new Logger(), 2 ); assertFalse( strategy.hasSharedThreadPool() ); assertTrue( strategy.canSchedule() ); Task task1 = new Task(); Task task2 = new Task(); strategy.schedule( task1 ); strategy.schedule( task2 ); assertTrue( strategy.canSchedule() ); assertTrue( strategy.finished() ); assertFalse( strategy.canSchedule() ); assertTrue( task1.result ); assertTrue( task2.result ); } |
JUnitCoreParameters { public boolean isPerCoreThreadCount() { return perCoreThreadCount; } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; } | @Test public void isPerCoreThreadCount() { assertFalse( newTestSetClasses().isPerCoreThreadCount() ); assertFalse( newTestSetMethods().isPerCoreThreadCount() ); assertTrue( newTestSetBoth().isPerCoreThreadCount() ); } |
JUnitCoreParameters { public int getThreadCount() { return threadCount; } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; } | @Test public void getThreadCount() { assertFalse( newTestSetClasses().isPerCoreThreadCount() ); assertFalse( newTestSetMethods().isPerCoreThreadCount() ); assertTrue( newTestSetBoth().isPerCoreThreadCount() ); } |
JUnitCoreParameters { public boolean isUseUnlimitedThreads() { return useUnlimitedThreads; } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; } | @Test public void isUseUnlimitedThreads() { assertFalse( newTestSetClasses().isUseUnlimitedThreads() ); assertTrue( newTestSetMethods().isUseUnlimitedThreads() ); assertFalse( newTestSetBoth().isUseUnlimitedThreads() ); } |
JUnitCoreParameters { public boolean isNoThreading() { return !isParallelismSelected(); } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; } | @Test public void isNoThreading() { assertFalse( newTestSetClasses().isNoThreading() ); assertFalse( newTestSetMethods().isNoThreading() ); assertFalse( newTestSetBoth().isNoThreading() ); } |
JUnitCoreParameters { public boolean isParallelismSelected() { return isParallelSuites() || isParallelClasses() || isParallelMethods(); } JUnitCoreParameters( Map<String, String> properties ); boolean isParallelMethods(); boolean isParallelClasses(); boolean isParallelSuites(); @Deprecated @SuppressWarnings( { "unused", "deprecation" } ) boolean isParallelBoth(); boolean isPerCoreThreadCount(); int getThreadCount(); int getThreadCountMethods(); int getThreadCountClasses(); int getThreadCountSuites(); boolean isUseUnlimitedThreads(); double getParallelTestsTimeoutInSeconds(); double getParallelTestsTimeoutForcedInSeconds(); boolean isNoThreading(); boolean isParallelismSelected(); boolean isParallelOptimization(); @Override String toString(); static final String PARALLEL_KEY; static final String PERCORETHREADCOUNT_KEY; static final String THREADCOUNT_KEY; static final String THREADCOUNTSUITES_KEY; static final String THREADCOUNTCLASSES_KEY; static final String THREADCOUNTMETHODS_KEY; static final String USEUNLIMITEDTHREADS_KEY; static final String PARALLEL_TIMEOUT_KEY; static final String PARALLEL_TIMEOUTFORCED_KEY; static final String PARALLEL_OPTIMIZE_KEY; } | @Test public void isAnyParallelismSelected() { assertTrue( newTestSetClasses().isParallelismSelected() ); assertTrue( newTestSetMethods().isParallelismSelected() ); assertTrue( newTestSetBoth().isParallelismSelected() ); } |
SchedulingStrategies { public static SchedulingStrategy createParallelSharedStrategy( ConsoleLogger logger, ExecutorService threadPool ) { if ( threadPool == null ) { throw new NullPointerException( "null threadPool in #createParallelSharedStrategy" ); } return new SharedThreadPoolStrategy( logger, threadPool ); } static SchedulingStrategy createInvokerStrategy( ConsoleLogger logger ); static SchedulingStrategy createParallelStrategy( ConsoleLogger logger, int nThreads ); static SchedulingStrategy createParallelStrategyUnbounded( ConsoleLogger logger ); static SchedulingStrategy createParallelSharedStrategy( ConsoleLogger logger, ExecutorService threadPool ); } | @Test(expected = NullPointerException.class) public void sharedPoolStrategyNullPool() { SchedulingStrategies.createParallelSharedStrategy( new Logger(), null ); }
@Test public void sharedPoolStrategy() throws InterruptedException { ExecutorService sharedPool = Executors.newCachedThreadPool( DAEMON_THREAD_FACTORY ); SchedulingStrategy strategy1 = SchedulingStrategies.createParallelSharedStrategy( new Logger(), sharedPool ); assertTrue( strategy1.hasSharedThreadPool() ); assertTrue( strategy1.canSchedule() ); SchedulingStrategy strategy2 = SchedulingStrategies.createParallelSharedStrategy( new Logger(), sharedPool ); assertTrue( strategy2.hasSharedThreadPool() ); assertTrue( strategy2.canSchedule() ); Task task1 = new Task(); Task task2 = new Task(); Task task3 = new Task(); Task task4 = new Task(); strategy1.schedule( task1 ); strategy2.schedule( task2 ); strategy1.schedule( task3 ); strategy2.schedule( task4 ); assertTrue( strategy1.canSchedule() ); assertTrue( strategy2.canSchedule() ); assertTrue( strategy1.finished() ); assertFalse( strategy1.canSchedule() ); assertTrue( strategy2.finished() ); assertFalse( strategy2.canSchedule() ); assertTrue( task1.result ); assertTrue( task2.result ); assertTrue( task3.result ); assertTrue( task4.result ); } |
SchedulingStrategies { public static SchedulingStrategy createParallelStrategyUnbounded( ConsoleLogger logger ) { return new NonSharedThreadPoolStrategy( logger, Executors.newCachedThreadPool( DAEMON_THREAD_FACTORY ) ); } static SchedulingStrategy createInvokerStrategy( ConsoleLogger logger ); static SchedulingStrategy createParallelStrategy( ConsoleLogger logger, int nThreads ); static SchedulingStrategy createParallelStrategyUnbounded( ConsoleLogger logger ); static SchedulingStrategy createParallelSharedStrategy( ConsoleLogger logger, ExecutorService threadPool ); } | @Test public void infinitePoolStrategy() throws InterruptedException { SchedulingStrategy strategy = SchedulingStrategies.createParallelStrategyUnbounded( new Logger() ); assertFalse( strategy.hasSharedThreadPool() ); assertTrue( strategy.canSchedule() ); Task task1 = new Task(); Task task2 = new Task(); strategy.schedule( task1 ); strategy.schedule( task2 ); assertTrue( strategy.canSchedule() ); assertTrue( strategy.finished() ); assertFalse( strategy.canSchedule() ); assertTrue( task1.result ); assertTrue( task2.result ); } |
ClassName { public String get() { return this.fullClassNameWithGenerics; } ClassName(String fullClassNameWithGenerics); String get(); String toString(); String getSimpleName(); String getPackageName(); List<String> getGenericsWithoutBounds(); List<String> getGenericsWithBounds(); String getGenericPart(); String getGenericPartWithoutBrackets(); String getWithoutGenericPart(); } | @Test public void stripRepeatedTypeVarsOfOuterClasses() { assertThat( new ClassName("java.util.Map<K, V>.Entry<K, V>").get(), is("java.util.Map.Entry<K, V>")); assertThat( new ClassName("java.util.Foo<K extends java.util.Bar<K>>.Entry<K extends java.util.Bar<K>>").get(), is("java.util.Foo.Entry<K extends java.util.Bar<K>>")); } |
ActionRouter { public void directAlertAction(Action action) { AlertActionRoute[] alertActionRoutes = AlertActionRoute.values(); for (AlertActionRoute alertActionRoute : alertActionRoutes) { if (alertActionRoute.identifier().equals(action.type())) { alertActionRoute.direct(action); return; } } logWarn("Unknown type in Alert action: " + action); } void directAlertAction(Action action); void directMotherAction(Action action); } | @Test public void assertDirectAlertActionTest() throws Exception { Action action = new Action("", "", "createAlert", null, "", false, null); actionRouter.directAlertAction(action); Assert.assertNotNull(actionRouter); } |
CryptographicHelper { public void generateKey(String keyAlias) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { legacyCryptography.generateKey(keyAlias); } else { mCryptography.generateKey(keyAlias); } } static CryptographicHelper getInstance(Context context_); static byte[] encrypt(byte[] data, String keyAlias); static byte[] decrypt(byte[] data, String keyAlias); void generateKey(String keyAlias); Key getKey(String keyAlias); void deleteKey(String keyAlias); void setLegacyCryptography(AndroidLegacyCryptography legacyCryptography); void setMCryptography(AndroidMCryptography androidMCryptography); } | @Test @Config(sdk = Build.VERSION_CODES.LOLLIPOP_MR1) public void testCryptographicHelperGenerateKeyInvokesLegacyGenerateKeyMethod() { cryptographicHelper.generateKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidLegacyCryptography).generateKey(SAMPLE_KEY_ALIAS); }
@Test public void testCryptographicHelperGenerateKeyInvokesAndroidMGenerateKeyMethod() { cryptographicHelper.generateKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidMCryptography).generateKey(SAMPLE_KEY_ALIAS); } |
CryptographicHelper { public Key getKey(String keyAlias) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { return legacyCryptography.getKey(keyAlias); } else { return mCryptography.getKey(keyAlias); } } static CryptographicHelper getInstance(Context context_); static byte[] encrypt(byte[] data, String keyAlias); static byte[] decrypt(byte[] data, String keyAlias); void generateKey(String keyAlias); Key getKey(String keyAlias); void deleteKey(String keyAlias); void setLegacyCryptography(AndroidLegacyCryptography legacyCryptography); void setMCryptography(AndroidMCryptography androidMCryptography); } | @Test public void testCryptographicHelperGetKeyInvokesAndroidMGetKeyMethod() { cryptographicHelper.getKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidMCryptography).getKey(SAMPLE_KEY_ALIAS); }
@Test @Config(sdk = Build.VERSION_CODES.LOLLIPOP_MR1) public void testCryptographicHelperGetKeyInvokesLegacyGetKeyMethod() { cryptographicHelper.getKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidLegacyCryptography).getKey(SAMPLE_KEY_ALIAS); } |
CryptographicHelper { public void deleteKey(String keyAlias) { if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) { legacyCryptography.deleteKey(keyAlias); } else { mCryptography.deleteKey(keyAlias); } } static CryptographicHelper getInstance(Context context_); static byte[] encrypt(byte[] data, String keyAlias); static byte[] decrypt(byte[] data, String keyAlias); void generateKey(String keyAlias); Key getKey(String keyAlias); void deleteKey(String keyAlias); void setLegacyCryptography(AndroidLegacyCryptography legacyCryptography); void setMCryptography(AndroidMCryptography androidMCryptography); } | @Test public void testCryptographicHelperDeleteKeyInvokesAndroidMGetKeyMethod() { cryptographicHelper.deleteKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidMCryptography).deleteKey(SAMPLE_KEY_ALIAS); }
@Test @Config(sdk = Build.VERSION_CODES.LOLLIPOP_MR1) public void testCryptographicHelperDeleteKeyInvokesLegacyGetKeyMethod() { cryptographicHelper.deleteKey(SAMPLE_KEY_ALIAS); Mockito.verify(androidLegacyCryptography).deleteKey(SAMPLE_KEY_ALIAS); } |
AndroidMCryptography extends BaseCryptography implements ICryptography { @Override public String getAESMode() { return AES_MODE; } AndroidMCryptography(Context context); @RequiresApi(api = Build.VERSION_CODES.KITKAT) @Override byte[] encrypt(byte[] input, String keyAlias); @Override String getAESMode(); void generateInitializationVector(); @RequiresApi(api = Build.VERSION_CODES.KITKAT) @Override byte[] decrypt(byte[] encrypted, String keyAlias); @Override Key getKey(String keyAlias); @TargetApi(Build.VERSION_CODES.M) @Override void generateKey(String keyAlias); static final String AES_MODE; } | @Test public void testAndroidMCryptographyClassInitsCorrectly() { Assert.assertNotNull(androidMCryptography); Assert.assertNotNull(androidMCryptography.secureRandom); Assert.assertNotNull(androidMCryptography.getAESMode()); Assert.assertEquals(AndroidMCryptography.AES_MODE, androidMCryptography.getAESMode()); } |
AndroidLegacyCryptography extends BaseCryptography implements ICryptography { @Override public String getAESMode() { return AES_MODE; } AndroidLegacyCryptography(Context context); @Override String getAESMode(); @Override byte[] encrypt(byte[] input, String keyAlias); @Override byte[] decrypt(byte[] encrypted, String keyAlias); @Override Key getKey(String keyAlias); @Override void generateKey(String keyAlias); String generateAESKey(String encryptedAESKeyKey, String rsaPrivateKeyAlias); void generateRSAKeys(String rsaKeyAlias); static final String AES_MODE; } | @Test public void testAndroidLegacyCryptographyClassInitsCorrectly() { Assert.assertNotNull(androidLegacyCryptography); Assert.assertNotNull(androidLegacyCryptography.secureRandom); Assert.assertNotNull(androidLegacyCryptography.getAESMode()); Assert.assertEquals(AndroidLegacyCryptography.AES_MODE, androidLegacyCryptography.getAESMode()); } |
ViewStubInflater { public ViewGroup get() { if (!isInflated()) { this.inflatedLayout = (ViewGroup) stub.inflate(); } return this.inflatedLayout; } ViewStubInflater(ViewStub stub); ViewGroup get(); void setVisibility(int visibility); } | @Test public void testGetInflatesLayoutCorrectly() { Mockito.doReturn(viewGroup).when(viewStub).inflate(); ViewStubInflater viewStubInflater = new ViewStubInflater(viewStub); Assert.assertNotNull(viewStubInflater); Assert.assertEquals(viewGroup, viewStubInflater.get()); } |
ViewStubInflater { public void setVisibility(int visibility) { if (isInflated()) { inflatedLayout.setVisibility(visibility); } } ViewStubInflater(ViewStub stub); ViewGroup get(); void setVisibility(int visibility); } | @Test public void testSetVisiblityInvokesInflatedLayoutWithCorrectParams() { Mockito.doReturn(viewGroup).when(viewStub).inflate(); ViewStubInflater viewStubInflater = Mockito.spy(new ViewStubInflater(viewStub)); viewStubInflater.setVisibility(View.GONE); Mockito.verify(viewStubInflater).setVisibility(View.GONE); viewStubInflater.setVisibility(View.VISIBLE); Mockito.verify(viewStubInflater).setVisibility(View.VISIBLE); viewStubInflater.setVisibility(View.INVISIBLE); Mockito.verify(viewStubInflater).setVisibility(View.INVISIBLE); } |
ChildRegisterProfilePhotoLoader implements ProfilePhotoLoader { public Drawable get(SmartRegisterClient client) { return FEMALE_GENDER.equalsIgnoreCase(((ChildSmartRegisterClient) client).gender()) ? femaleInfantDrawable : maleInfantDrawable; } ChildRegisterProfilePhotoLoader(Drawable maleInfantDrawable, Drawable
femaleInfantDrawable); Drawable get(SmartRegisterClient client); } | @Test public void testGetReturnsCorrectDrawableForFemaleGender() { Drawable maleInfant = RuntimeEnvironment.application.getDrawable(R.drawable.child_boy_infant); Drawable femaleInfant = RuntimeEnvironment.application.getDrawable(R.drawable.child_girl_infant); ChildRegisterProfilePhotoLoader childRegisterProfilePhotoLoader = new ChildRegisterProfilePhotoLoader(maleInfant, femaleInfant); Assert.assertNotNull(childRegisterProfilePhotoLoader); Mockito.doReturn("female").when(smartRegisterClient).gender(); Assert.assertEquals(femaleInfant, childRegisterProfilePhotoLoader.get(smartRegisterClient)); }
@Test public void testGetReturnsCorrectDrawableForMaleGender() { Drawable maleInfant = RuntimeEnvironment.application.getDrawable(R.drawable.child_boy_infant); Drawable femaleInfant = RuntimeEnvironment.application.getDrawable(R.drawable.child_girl_infant); ChildRegisterProfilePhotoLoader childRegisterProfilePhotoLoader = new ChildRegisterProfilePhotoLoader(maleInfant, femaleInfant); Assert.assertNotNull(childRegisterProfilePhotoLoader); Mockito.doReturn("male").when(smartRegisterClient).gender(); Assert.assertEquals(maleInfant, childRegisterProfilePhotoLoader.get(smartRegisterClient)); } |
JsonFormUtils { public static Map<String, String> sectionFields(JSONObject jsonForm) { try { JSONObject step1 = jsonForm.has(STEP1) ? jsonForm.getJSONObject(STEP1) : null; if (step1 == null) { return null; } JSONArray sections = step1.has(SECTIONS) ? step1.getJSONArray(SECTIONS) : null; if (sections == null) { return null; } Map<String, String> result = new HashMap<>(); for (int i = 0; i < sections.length(); i++) { JSONObject sectionsJSONObject = sections.getJSONObject(i); if (sectionsJSONObject.has(FIELDS)) { JSONArray fieldsArray = sectionsJSONObject.getJSONArray(FIELDS); for (int j = 0; j < fieldsArray.length(); j++) { JSONObject fieldJsonObject = fieldsArray.getJSONObject(j); String key = fieldJsonObject.getString(KEY); String value = fieldJsonObject.getString(VALUE); result.put(key, value); } } } return result; } catch (JSONException e) { Timber.e(e); return null; } } static Client createBaseClient(JSONArray fields, FormTag formTag, String entityId); static Event createEvent(JSONArray fields, JSONObject metadata, FormTag formTag, String entityId, String encounterType, String bindType); static void addObservation(Event e, JSONObject jsonObject); static Map<String, String> extractIdentifiers(JSONArray fields); static Map<String, Object> extractAttributes(JSONArray fields); static Map<String, Address> extractAddresses(JSONArray fields); static void fillIdentifiers(Map<String, String> pids, JSONObject jsonObject); static void fillAttributes(Map<String, Object> pattributes, JSONObject jsonObject); static void fillAddressFields(JSONObject jsonObject, Map<String, Address> addresses); static Map<String, String> extractIdentifiers(JSONArray fields, String bindType); static Map<String, Object> extractAttributes(JSONArray fields, String bindType); static Map<String, Address> extractAddresses(JSONArray fields, String bindType); static String getSubFormFieldValue(JSONArray jsonArray, FormEntityConstants.Person person, String bindType); static void fillSubFormIdentifiers(Map<String, String> pids, JSONObject jsonObject, String bindType); static void fillSubFormAttributes(Map<String, Object> pattributes, JSONObject jsonObject, String bindType); static void fillSubFormAddressFields(JSONObject jsonObject, Map<String, Address> addresses, String bindType); static JSONArray getSingleStepFormfields(JSONObject jsonForm); static JSONArray fields(JSONObject jsonForm); static JSONArray getMultiStepFormFields(JSONObject jsonForm); static Map<String, String> sectionFields(JSONObject jsonForm); static JSONObject toJSONObject(String jsonString); static String getFieldValue(JSONArray jsonArray, FormEntityConstants.Person person); static String getFieldValue(JSONArray jsonArray, FormEntityConstants.Encounter encounter); static String getFieldValue(String jsonString, String key); @Nullable static JSONObject getFieldJSONObject(JSONArray jsonArray, String key); @Nullable static String value(JSONArray jsonArray, String entity, String entityId); @Nullable static String getFieldValue(JSONArray jsonArray, String key); @Nullable static JSONObject getJSONObject(JSONArray jsonArray, int index); @Nullable static JSONArray getJSONArray(JSONObject jsonObject, String field); static JSONObject getJSONObject(JSONObject jsonObject, String field); static String getString(JSONObject jsonObject, String field); static String getString(String jsonString, String field); static Long getLong(JSONObject jsonObject, String field); static Date formatDate(String dateString, boolean startOfToday); static String generateRandomUUIDString(); static void addToJSONObject(JSONObject jsonObject, String key, String value); static String formatDate(String date); static JSONObject merge(JSONObject original, JSONObject updated); static String[] getNames(JSONObject jo); static String convertToOpenMRSDate(String value); static boolean isBlankJsonArray(JSONArray jsonArray); static boolean isBlankJsonObject(JSONObject jsonObject); static final String TAG; static final String OPENMRS_ENTITY; static final String OPENMRS_ENTITY_ID; static final String OPENMRS_ENTITY_PARENT; static final String OPENMRS_CHOICE_IDS; static final String OPENMRS_DATA_TYPE; static final String PERSON_ATTRIBUTE; static final String PERSON_INDENTIFIER; static final String PERSON_ADDRESS; static final String SIMPRINTS_GUID; static final String FINGERPRINT_KEY; static final String FINGERPRINT_OPTION; static final String FINGERPRINT_OPTION_REGISTER; static final String CONCEPT; static final String VALUE; static final String VALUES; static final String FIELDS; static final String KEY; static final String ENTITY_ID; static final String STEP1; static final String SECTIONS; static final String attributes; static final String ENCOUNTER; static final String ENCOUNTER_LOCATION; static final String SAVE_OBS_AS_ARRAY; static final String SAVE_ALL_CHECKBOX_OBS_AS_ARRAY; static final SimpleDateFormat dd_MM_yyyy; static Gson gson; } | @Test public void testSectionFieldsShouldGetCorrectSectionMap() throws JSONException { Map<String, String> sectionsMap = JsonFormUtils.sectionFields(new JSONObject(SINGLE_STEP_WITH_SECTIONS)); assertEquals("gps", sectionsMap.get("gps")); assertNotNull("scan_respiratory_specimen_barcode", sectionsMap.get("lbl_scan_respiratory_specimen_barcode")); assertNotNull("affix_respiratory_specimen_label", sectionsMap.get("lbl_affix_respiratory_specimen_label")); } |
OnClickFormLauncher implements View.OnClickListener { @Override public void onClick(View view) { activity.startFormActivity(formName, entityId, metaData); } OnClickFormLauncher(SecuredActivity activity, String formName, String entityId); OnClickFormLauncher(SecuredActivity activity, String formName, String entityId, String
metaData); @Override void onClick(View view); } | @Test public void testOnClickInvokesStartFormActivityWithCorrectParams() { String testMetadata = "{\"fieldOverrides\": \"metadata-override-values\"}"; Mockito.doNothing().when(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata); OnClickFormLauncher onClickFormLauncher = new OnClickFormLauncher(activity, TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata); Assert.assertNotNull(onClickFormLauncher); onClickFormLauncher.onClick(view); Mockito.verify(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata); }
@Test public void testOnClickInvokesStartFormActivityWithCorrectParamsNoMetadata() { Mockito.doNothing().when(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, ""); OnClickFormLauncher onClickFormLauncher = new OnClickFormLauncher(activity, TEST_FORM_NAME, TEST_BASE_ENTITY_ID); Assert.assertNotNull(onClickFormLauncher); onClickFormLauncher.onClick(view); Mockito.verify(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, (String) null); }
@Test public void testOnClickInvokesStartFormActivityWithCorrectMapMetadataParams() { Map<String, String> testMetadata = new HashMap<>(); testMetadata.put("first_name", "john"); testMetadata.put("last_name", "doe"); Mockito.doNothing().when(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata); OnClickFormLauncher onClickFormLauncher = new OnClickFormLauncher(activity, TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata.toString()); Assert.assertNotNull(onClickFormLauncher); onClickFormLauncher.onClick(view); Mockito.verify(activity, Mockito.times(1)).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata.toString()); }
@Test public void testOnClickInvokesStartFormActivityWithEmptyMapMetadataParams() { Map<String, String> testMetadata = new HashMap<>(); Mockito.doNothing().when(activity).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata); OnClickFormLauncher onClickFormLauncher = new OnClickFormLauncher(activity, TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata.toString()); Assert.assertNotNull(onClickFormLauncher); onClickFormLauncher.onClick(view); Mockito.verify(activity, Mockito.times(1)).startFormActivity(TEST_FORM_NAME, TEST_BASE_ENTITY_ID, testMetadata.toString()); } |
SecuredFragment extends Fragment { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); logoutListener = data -> { if (getActivity() != null && !getActivity().isFinishing()) { getActivity().finish(); } }; Event.ON_LOGOUT.addListener(logoutListener); if (context().IsUserLoggedOut()) { DrishtiApplication application = (DrishtiApplication) this.getActivity() .getApplication(); application.logoutCurrentUser(); return; } if (getActivity() instanceof SecuredActivity) { formController = new FormController((SecuredActivity) getActivity()); } anmController = context().anmController(); navigationController = new NavigationController(getActivity(), anmController); onCreation(); } @Override void onCreate(Bundle savedInstanceState); @Override void onResume(); @Override void onPause(); @Override boolean onOptionsItemSelected(MenuItem item); void logoutUser(); void startFormActivity(String formName, String entityId, String metaData); void startMicroFormActivity(String formName, String entityId, String metaData); boolean isPaused(); } | @Test public void testOnCreateInitializesFragmentFields() { securedFragment.onCreate(bundle); Listener<Boolean> logoutListener = ReflectionHelpers.getField(securedFragment, "logoutListener"); FormController formController = ReflectionHelpers.getField(securedFragment, "formController"); ANMController anmController = ReflectionHelpers.getField(securedFragment, "anmController"); NavigationController navigationController = ReflectionHelpers.getField(securedFragment, "navigationController"); Assert.assertNotNull(logoutListener); Assert.assertNotNull(formController); Assert.assertNotNull(anmController); Assert.assertNotNull(navigationController); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.