Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: IsFallingRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { if (minStrenght >= 1) { minStrenght = 0.99; } int count = 0; for (int i = Math.max(0, index - barCount + 1); i <= index; i++) { if (ref.getValue(i).isLessThan(ref.getValue(Math.max(0, i - 1)))) { count += 1; } } double ratio = count / (double) barCount; final boolean satisfied = ratio >= minStrenght; traceIsSatisfied(index, satisfied); return satisfied; } IsFallingRule(Indicator<Num> ref, int barCount); IsFallingRule(Indicator<Num> ref, int barCount, double minStrenght); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertTrue(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertTrue(rule.isSatisfied(6)); assertTrue(rule.isSatisfied(7)); assertFalse(rule.isSatisfied(8)); assertFalse(rule.isSatisfied(9)); }
### Question: CrossedUpIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = cross.getValue(index); traceIsSatisfied(index, satisfied); return satisfied; } CrossedUpIndicatorRule(Indicator<Num> indicator, Number threshold); CrossedUpIndicatorRule(Indicator<Num> indicator, Num threshold); CrossedUpIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Indicator<Num> getLow(); Indicator<Num> getUp(); }### Answer: @Test public void isSatisfied() { assertFalse(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); }
### Question: AroonUpIndicator extends CachedIndicator<Num> { @Override public String toString() { return getClass().getSimpleName() + " barCount: " + barCount; } AroonUpIndicator(Indicator<Num> maxValueIndicator, int barCount); AroonUpIndicator(BarSeries series, int barCount); @Override String toString(); }### Answer: @Test public void onlyNaNValues() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 1000; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } AroonUpIndicator aroonUpIndicator = new AroonUpIndicator(series, 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), aroonUpIndicator.getValue(i).toString()); } } @Test public void naNValuesInIntervall() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10; i++) { Num maxPrice = i % 2 == 0 ? series.numOf(i) : NaN; series.addBar(ZonedDateTime.now().plusDays(i), NaN, maxPrice, NaN, NaN, NaN); } AroonUpIndicator aroonUpIndicator = new AroonUpIndicator(series, 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { if (i % 2 != 0) { assertEquals(NaN.toString(), aroonUpIndicator.getValue(i).toString()); } else { assertNumEquals(aroonUpIndicator.getValue(i).toString(), series.numOf(100)); } } }
### Question: UnderIndicatorRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = first.getValue(index).isLessThan(second.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } UnderIndicatorRule(Indicator<Num> indicator, Number threshold); UnderIndicatorRule(Indicator<Num> indicator, Num threshold); UnderIndicatorRule(Indicator<Num> first, Indicator<Num> second); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertFalse(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); assertTrue(rule.isSatisfied(4)); assertFalse(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); }
### Question: PeriodicalGrowthRateIndicator extends CachedIndicator<Num> { public Num getTotalReturn() { Num totalProduct = one; int completeTimeFrames = (getBarSeries().getBarCount() / barCount); for (int i = 1; i <= completeTimeFrames; i++) { int index = i * barCount; Num currentReturn = getValue(index); if (currentReturn != NaN) { currentReturn = currentReturn.plus(one); totalProduct = totalProduct.multipliedBy(currentReturn); } } return totalProduct.pow(one.dividedBy(numOf(completeTimeFrames))); } PeriodicalGrowthRateIndicator(Indicator<Num> indicator, int barCount); Num getTotalReturn(); }### Answer: @Test public void testGetTotalReturn() { PeriodicalGrowthRateIndicator gri = new PeriodicalGrowthRateIndicator(this.closePrice, 5); Num result = gri.getTotalReturn(); assertNumEquals(0.9564, result); }
### Question: LowestValueIndicator extends CachedIndicator<Num> { @Override public String toString() { return getClass().getSimpleName() + " barCount: " + barCount; } LowestValueIndicator(Indicator<Num> indicator, int barCount); @Override String toString(); }### Answer: @Test public void onlyNaNValues() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10000; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } LowestValueIndicator lowestValue = new LowestValueIndicator(new ClosePriceIndicator(series), 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), lowestValue.getValue(i).toString()); } } @Test public void naNValuesInIntervall() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } LowestValueIndicator lowestValue = new LowestValueIndicator(new ClosePriceIndicator(series), 2); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { if (i % 2 != 0) { assertEquals(series.getBar(i - 1).getClosePrice().toString(), lowestValue.getValue(i).toString()); } else assertEquals(series.getBar(Math.max(0, i - 1)).getClosePrice().toString(), lowestValue.getValue(i).toString()); } }
### Question: HighestValueIndicator extends CachedIndicator<Num> { @Override public String toString() { return getClass().getSimpleName() + " barCount: " + barCount; } HighestValueIndicator(Indicator<Num> indicator, int barCount); @Override String toString(); }### Answer: @Test public void onlyNaNValues() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10000; i++) { series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, NaN, NaN); } HighestValueIndicator highestValue = new HighestValueIndicator(new ClosePriceIndicator(series), 5); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { assertEquals(NaN.toString(), highestValue.getValue(i).toString()); } } @Test public void naNValuesInIntervall() { BaseBarSeries series = new BaseBarSeries("NaN test"); for (long i = 0; i <= 10; i++) { Num closePrice = i % 2 == 0 ? series.numOf(i) : NaN; series.addBar(ZonedDateTime.now().plusDays(i), NaN, NaN, NaN, closePrice, NaN); } HighestValueIndicator highestValue = new HighestValueIndicator(new ClosePriceIndicator(series), 2); for (int i = series.getBeginIndex(); i <= series.getEndIndex(); i++) { if (i % 2 != 0) assertEquals(series.getBar(i - 1).getClosePrice().toString(), highestValue.getValue(i).toString()); else assertEquals(series.getBar(i).getClosePrice().toString(), highestValue.getValue(i).toString()); } }
### Question: ConstantIndicator extends AbstractIndicator<T> { public ConstantIndicator(BarSeries series, T t) { super(series); this.value = t; } ConstantIndicator(BarSeries series, T t); @Override T getValue(int index); @Override String toString(); }### Answer: @Test public void constantIndicator() { assertNumEquals("30.33", constantIndicator.getValue(0)); assertNumEquals("30.33", constantIndicator.getValue(1)); assertNumEquals("30.33", constantIndicator.getValue(10)); assertNumEquals("30.33", constantIndicator.getValue(30)); }
### Question: FixedIndicator extends AbstractIndicator<T> { @Override public T getValue(int index) { return values.get(index); } @SafeVarargs FixedIndicator(BarSeries series, T... values); void addValue(T value); @Override T getValue(int index); }### Answer: @Test public void getValueOnFixedDecimalIndicator() { BarSeries series = new BaseBarSeries(); FixedDecimalIndicator fixedDecimalIndicator = new FixedDecimalIndicator(series, 13.37, 42, -17); assertNumEquals(13.37, fixedDecimalIndicator.getValue(0)); assertNumEquals(42, fixedDecimalIndicator.getValue(1)); assertNumEquals(-17, fixedDecimalIndicator.getValue(2)); fixedDecimalIndicator = new FixedDecimalIndicator(series, "3.0", "-123.456", "0.0"); assertNumEquals("3.0", fixedDecimalIndicator.getValue(0)); assertNumEquals("-123.456", fixedDecimalIndicator.getValue(1)); assertNumEquals("0.0", fixedDecimalIndicator.getValue(2)); } @Test public void getValueOnFixedBooleanIndicator() { BarSeries series = new BaseBarSeries(); FixedBooleanIndicator fixedBooleanIndicator = new FixedBooleanIndicator(series, false, false, true, false, true); Assert.assertFalse(fixedBooleanIndicator.getValue(0)); Assert.assertFalse(fixedBooleanIndicator.getValue(1)); Assert.assertTrue(fixedBooleanIndicator.getValue(2)); Assert.assertFalse(fixedBooleanIndicator.getValue(3)); Assert.assertTrue(fixedBooleanIndicator.getValue(4)); }
### Question: InPipeRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = ref.getValue(index).isLessThanOrEqual(upper.getValue(index)) && ref.getValue(index).isGreaterThanOrEqual(lower.getValue(index)); traceIsSatisfied(index, satisfied); return satisfied; } InPipeRule(Indicator<Num> ref, Number upper, Number lower); InPipeRule(Indicator<Num> ref, Num upper, Num lower); InPipeRule(Indicator<Num> ref, Indicator<Num> upper, Indicator<Num> lower); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertTrue(rule.isSatisfied(2)); assertFalse(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertTrue(rule.isSatisfied(6)); assertTrue(rule.isSatisfied(7)); assertFalse(rule.isSatisfied(8)); assertFalse(rule.isSatisfied(9)); }
### Question: WMAIndicator extends CachedIndicator<Num> { @Override protected Num calculate(int index) { if (index == 0) { return indicator.getValue(0); } Num value = numOf(0); if (index - barCount < 0) { for (int i = index + 1; i > 0; i--) { value = value.plus(numOf(i).multipliedBy(indicator.getValue(i - 1))); } return value.dividedBy(numOf(((index + 1) * (index + 2)) / 2)); } int actualIndex = index; for (int i = barCount; i > 0; i--) { value = value.plus(numOf(i).multipliedBy(indicator.getValue(actualIndex))); actualIndex--; } return value.dividedBy(numOf((barCount * (barCount + 1)) / 2)); } WMAIndicator(Indicator<Num> indicator, int barCount); @Override String toString(); }### Answer: @Test public void calculate() { MockBarSeries series = new MockBarSeries(numFunction, 1d, 2d, 3d, 4d, 5d, 6d); Indicator<Num> close = new ClosePriceIndicator(series); Indicator<Num> wmaIndicator = new WMAIndicator(close, 3); assertNumEquals(1, wmaIndicator.getValue(0)); assertNumEquals(1.6667, wmaIndicator.getValue(1)); assertNumEquals(2.3333, wmaIndicator.getValue(2)); assertNumEquals(3.3333, wmaIndicator.getValue(3)); assertNumEquals(4.3333, wmaIndicator.getValue(4)); assertNumEquals(5.3333, wmaIndicator.getValue(5)); }
### Question: FixedRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { boolean satisfied = false; for (int idx : indexes) { if (idx == index) { satisfied = true; break; } } traceIsSatisfied(index, satisfied); return satisfied; } FixedRule(int... indexes); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { FixedRule fixedRule = new FixedRule(); assertFalse(fixedRule.isSatisfied(0)); assertFalse(fixedRule.isSatisfied(1)); assertFalse(fixedRule.isSatisfied(2)); assertFalse(fixedRule.isSatisfied(9)); fixedRule = new FixedRule(1, 2, 3); assertFalse(fixedRule.isSatisfied(0)); assertTrue(fixedRule.isSatisfied(1)); assertTrue(fixedRule.isSatisfied(2)); assertTrue(fixedRule.isSatisfied(3)); assertFalse(fixedRule.isSatisfied(4)); assertFalse(fixedRule.isSatisfied(5)); assertFalse(fixedRule.isSatisfied(6)); assertFalse(fixedRule.isSatisfied(7)); assertFalse(fixedRule.isSatisfied(8)); assertFalse(fixedRule.isSatisfied(9)); assertFalse(fixedRule.isSatisfied(10)); }
### Question: Returns implements Indicator<Num> { public int getSize() { return barSeries.getBarCount() - 1; } Returns(BarSeries barSeries, Trade trade, ReturnType type); Returns(BarSeries barSeries, TradingRecord tradingRecord, ReturnType type); List<Num> getValues(); @Override Num getValue(int index); @Override BarSeries getBarSeries(); @Override Num numOf(Number number); int getSize(); void calculate(Trade trade); void calculate(Trade trade, int finalIndex); }### Answer: @Test public void returnSize() { for (Returns.ReturnType type : Returns.ReturnType.values()) { BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 2d, 3d, 4d, 5d); Returns returns = new Returns(sampleBarSeries, new BaseTradingRecord(), type); assertEquals(4, returns.getSize()); } }
### Question: CashFlow implements Indicator<Num> { public int getSize() { return barSeries.getBarCount(); } CashFlow(BarSeries barSeries, Trade trade); CashFlow(BarSeries barSeries, TradingRecord tradingRecord); CashFlow(BarSeries barSeries, TradingRecord tradingRecord, int finalIndex); @Override Num getValue(int index); @Override BarSeries getBarSeries(); @Override Num numOf(Number number); int getSize(); }### Answer: @Test public void cashFlowSize() { BarSeries sampleBarSeries = new MockBarSeries(numFunction, 1d, 2d, 3d, 4d, 5d); CashFlow cashFlow = new CashFlow(sampleBarSeries, new BaseTradingRecord()); assertEquals(5, cashFlow.getSize()); }
### Question: IsLowestRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { LowestValueIndicator lowest = new LowestValueIndicator(ref, barCount); Num lowestVal = lowest.getValue(index); Num refVal = ref.getValue(index); final boolean satisfied = !refVal.isNaN() && !lowestVal.isNaN() && refVal.equals(lowestVal); traceIsSatisfied(index, satisfied); return satisfied; } IsLowestRule(Indicator<Num> ref, int barCount); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); }### Answer: @Test public void isSatisfied() { assertTrue(rule.isSatisfied(0)); assertTrue(rule.isSatisfied(1)); assertFalse(rule.isSatisfied(2)); assertTrue(rule.isSatisfied(3)); assertFalse(rule.isSatisfied(4)); assertTrue(rule.isSatisfied(5)); assertFalse(rule.isSatisfied(6)); assertFalse(rule.isSatisfied(7)); assertFalse(rule.isSatisfied(8)); assertTrue(rule.isSatisfied(9)); }
### Question: NumberOfLosingTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isLosingTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); assertNumEquals(0, getCriterion().calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(1, series), Order.sellAt(3, series), Order.buyAt(3, series), Order.sellAt(4, series)); assertNumEquals(2, getCriterion().calculate(series, tradingRecord)); } @Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); Trade trade = new Trade(Order.buyAt(1, series), Order.sellAt(3, series)); assertNumEquals(1, getCriterion().calculate(series, trade)); }
### Question: NumberOfLosingTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); }
### Question: VersusBuyAndHoldCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } VersusBuyAndHoldCriterion(AnalysisCriterion criterion); @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(new TotalProfitCriterion()); assertTrue(criterion.betterThan(numOf(2.0), numOf(1.5))); assertFalse(criterion.betterThan(numOf(1.5), numOf(2.0))); }
### Question: NumberOfWinningTradesCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { long numberOfLosingTrades = tradingRecord.getTrades().stream().filter(Trade::isClosed) .filter(trade -> isWinningTrade(series, trade)).count(); return series.numOf(numberOfLosingTrades); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); assertNumEquals(0, getCriterion().calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); assertNumEquals(2, getCriterion().calculate(series, tradingRecord)); } @Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); Trade trade = new Trade(Order.buyAt(0, series), Order.sellAt(2, series)); assertNumEquals(1, getCriterion().calculate(series, trade)); }
### Question: NotRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = !ruleToNegate.isSatisfied(index, tradingRecord); traceIsSatisfied(index, satisfied); return satisfied; } NotRule(Rule ruleToNegate); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Rule getRuleToNegate(); }### Answer: @Test public void isSatisfied() { assertFalse(satisfiedRule.negation().isSatisfied(0)); assertTrue(unsatisfiedRule.negation().isSatisfied(0)); assertFalse(satisfiedRule.negation().isSatisfied(10)); assertTrue(unsatisfiedRule.negation().isSatisfied(10)); }
### Question: NumberOfWinningTradesCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isLessThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(3), numOf(6))); assertFalse(criterion.betterThan(numOf(7), numOf(4))); }
### Question: BuyAndHoldCriterion extends AbstractAnalysisCriterion { @Override public boolean betterThan(Num criterionValue1, Num criterionValue2) { return criterionValue1.isGreaterThan(criterionValue2); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void betterThan() { AnalysisCriterion criterion = getCriterion(); assertTrue(criterion.betterThan(numOf(1.3), numOf(1.1))); assertFalse(criterion.betterThan(numOf(0.6), numOf(0.9))); }
### Question: NumberOfBarsCriterion extends AbstractAnalysisCriterion { @Override public Num calculate(BarSeries series, TradingRecord tradingRecord) { return tradingRecord.getTrades().stream().filter(Trade::isClosed).map(t -> calculate(series, t)) .reduce(series.numOf(0), Num::plus); } @Override Num calculate(BarSeries series, TradingRecord tradingRecord); @Override Num calculate(BarSeries series, Trade trade); @Override boolean betterThan(Num criterionValue1, Num criterionValue2); }### Answer: @Test public void calculateWithNoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); AnalysisCriterion numberOfBars = getCriterion(); assertNumEquals(0, numberOfBars.calculate(series, new BaseTradingRecord())); } @Test public void calculateWithTwoTrades() { MockBarSeries series = new MockBarSeries(numFunction, 100, 105, 110, 100, 95, 105); TradingRecord tradingRecord = new BaseTradingRecord(Order.buyAt(0, series), Order.sellAt(2, series), Order.buyAt(3, series), Order.sellAt(5, series)); AnalysisCriterion numberOfBars = getCriterion(); assertNumEquals(6, numberOfBars.calculate(series, tradingRecord)); } @Test public void calculateWithOneTrade() { MockBarSeries series = new MockBarSeries(numFunction, 100, 95, 100, 80, 85, 70); Trade t = new Trade(Order.buyAt(2, series), Order.sellAt(5, series)); AnalysisCriterion numberOfBars = getCriterion(); assertNumEquals(4, numberOfBars.calculate(series, t)); }
### Question: AndRule extends AbstractRule { @Override public boolean isSatisfied(int index, TradingRecord tradingRecord) { final boolean satisfied = rule1.isSatisfied(index, tradingRecord) && rule2.isSatisfied(index, tradingRecord); traceIsSatisfied(index, satisfied); return satisfied; } AndRule(Rule rule1, Rule rule2); @Override boolean isSatisfied(int index, TradingRecord tradingRecord); Rule getRule1(); Rule getRule2(); }### Answer: @Test public void isSatisfied() { assertFalse(satisfiedRule.and(BooleanRule.FALSE).isSatisfied(0)); assertFalse(BooleanRule.FALSE.and(satisfiedRule).isSatisfied(0)); assertFalse(unsatisfiedRule.and(BooleanRule.FALSE).isSatisfied(0)); assertFalse(BooleanRule.FALSE.and(unsatisfiedRule).isSatisfied(0)); assertTrue(satisfiedRule.and(BooleanRule.TRUE).isSatisfied(10)); assertTrue(BooleanRule.TRUE.and(satisfiedRule).isSatisfied(10)); assertFalse(unsatisfiedRule.and(BooleanRule.TRUE).isSatisfied(10)); assertFalse(BooleanRule.TRUE.and(unsatisfiedRule).isSatisfied(10)); }
### Question: RESTService extends Service { @Override public final String getAlias() { try { String pathPrefix = null; for (Annotation classAnnotation : this.getClass().getAnnotations()) { if (classAnnotation instanceof ServicePath) { pathPrefix = ((ServicePath) classAnnotation).value(); break; } } if (pathPrefix == null) { throw new Exception("ServicePath annotation for service class is required!"); } pathPrefix = pathPrefix.trim(); pathPrefix = pathPrefix.replaceAll("(^/)\|(/$)", ""); if (pathPrefix.length() == 0) { throw new Exception("ServicePath annotation for service class is required!"); } return pathPrefix; } catch (Exception e) { } return null; } RESTService(); final RESTResponse handle(URI baseUri, URI requestUri, String method, byte[] body, Map<String, List<String>> headers); final String getSwagger(); @Override final String getAlias(); }### Answer: @Test public void testAlias() { assertEquals("service1", testee.getAlias()); }
### Question: ServiceAliasManager { public AliasResolveResponse resolvePathToServiceName(String path) throws AliasNotFoundException { List<String> split = splitPath(path); int level = 0; String currentKey = null; while (level < split.size() && level < MAX_PATH_LEVEL) { if (currentKey == null) { currentKey = split.get(level); } else { currentKey += SEPERATOR + split.get(level); } String currentEntry = null; try { currentEntry = getEntry(currentKey); } catch (EnvelopeException \| CryptoException \| AgentAccessDeniedException \| SerializationException e) { throw new AliasNotFoundException("Path does not exist.", e); } if (!currentEntry.equals(BLANK)) { return new AliasResolveResponse(currentEntry, level + 1); } level++; } if (level == MAX_PATH_LEVEL) { throw new AliasNotFoundException("Given path is too long."); } throw new AliasNotFoundException("Given path does not fit any alias."); } ServiceAliasManager(Node node); void registerServiceAlias(ServiceAgentImpl agent, String alias); AliasResolveResponse resolvePathToServiceName(String path); }### Answer: @Test public void testIntegration() throws CryptoException, InternalSecurityException, AgentAlreadyRegisteredException, AgentException, AliasNotFoundException, AgentAccessDeniedException { LocalNode node = new LocalNodeManager().launchNode(); node.startService(ServiceNameVersion.fromString("[email protected]"), "asdf"); assertEquals("i5.las2peer.api.TestService", node.getServiceAliasManager().resolvePathToServiceName("test").getServiceName()); }
### Question: MessageEnvelope implements Message { public String getContent() { return content; } MessageEnvelope(NodeHandle sendingNode, String content); MessageEnvelope(NodeHandle sendingNode, i5.las2peer.communication.Message content); NodeHandle getSendingNode(); String getContent(); i5.las2peer.communication.Message getContainedMessage(); @Override int getPriority(); }### Answer: @Test public void testSimpleContent() { try { String data = "some data to test"; MessageEnvelope testee = new MessageEnvelope(null, data); byte[] serialized = SerializeTools.serialize(testee); MessageEnvelope andBack = (MessageEnvelope) SerializeTools.deserialize(serialized); assertEquals(data, andBack.getContent()); } catch (Exception e) { e.printStackTrace(); Assert.fail(e.toString()); } }
### Question: ServiceClassLoader extends ClassLoader { public LoadedLibrary getLibrary() { return library; } ServiceClassLoader(LoadedLibrary lib, ClassLoader parent, ClassLoaderPolicy policy); LoadedLibrary getLibrary(); @Override URL getResource(String resourceName); }### Answer: @Test public void test() throws IllegalArgumentException, IOException { LoadedLibrary lib = LoadedJarLibrary .createFromJar("export/jars/i5.las2peer.classLoaders.testPackage2-1.0.jar"); ServiceClassLoader testee = new ServiceClassLoader(lib, null, new DefaultPolicy()); assertEquals("i5.las2peer.classLoaders.testPackage2", testee.getLibrary().getIdentifier().getName()); assertEquals("1.0", testee.getLibrary().getIdentifier().getVersion().toString()); }
### Question: RESTService extends Service { public final RESTResponse handle(URI baseUri, URI requestUri, String method, byte[] body, Map<String, List<String>> headers) { final ResponseWriter responseWriter = new ResponseWriter(); final ContainerRequest requestContext = new ContainerRequest(baseUri, requestUri, method, getSecurityContext(), new MapPropertiesDelegate()); requestContext.setEntityStream(new ByteArrayInputStream(body)); requestContext.getHeaders().putAll(headers); requestContext.setWriter(responseWriter); try { appHandler.handle(requestContext); } finally { responseWriter.commit(); } return responseWriter.getResponse(); } RESTService(); final RESTResponse handle(URI baseUri, URI requestUri, String method, byte[] body, Map<String, List<String>> headers); final String getSwagger(); @Override final String getAlias(); }### Answer: @Test public void testHandle() throws URISyntaxException { RESTResponse response = invoke(testee, "GET", "hello", ""); assertEquals(200, response.getHttpCode()); assertEquals("Hello World!", new String(response.getBody())); }
### Question: ServiceClassLoader extends ClassLoader { URL getResource(String resourceName, boolean lookUp) { Logger.logGetResource(this, resourceName, null, lookUp); URL res; try { res = library.getResourceAsUrl(resourceName); } catch (ResourceNotFoundException e) { if (lookUp && parent != null) { URL result = parent.getResource(resourceName); if (result != null) { return result; } else { Logger.logGetResource(this, resourceName, false, null); return null; } } else { Logger.logGetResource(this, resourceName, false, null); return null; } } if (res != null) { Logger.logGetResource(this, resourceName, true, null); return res; } else { return null; } } ServiceClassLoader(LoadedLibrary lib, ClassLoader parent, ClassLoaderPolicy policy); LoadedLibrary getLibrary(); @Override URL getResource(String resourceName); }### Answer: @Test public void testResources() throws IllegalArgumentException, IOException { LoadedLibrary lib = LoadedJarLibrary .createFromJar("export/jars/i5.las2peer.classLoaders.testPackage1-1.0.jar"); ServiceClassLoader testee = new ServiceClassLoader(lib, null, new DefaultPolicy()); Properties properties = new Properties(); properties.load(testee.getResourceAsStream("i5/las2peer/classLoaders/testPackage1/test.properties")); assertEquals("123", properties.getProperty("integer")); assertEquals("value", properties.getProperty("attribute")); URL test = testee.getResource("does/not/exist"); assertNull(test); }
### Question: ClassManager { public static final String getPackageName(String className) { if (className.indexOf('.') < 0) { throw new IllegalArgumentException("this class is not contained in a package!"); } return className.substring(0, className.lastIndexOf('.')); } ClassManager(Repository repository, ClassLoader platformLoader, ClassLoaderPolicy policy); ClassManager(Repository[] repositories, ClassLoader platformLoader, ClassLoaderPolicy policy); ClassManager(List<Repository> repositories, ClassLoader platformLoader, ClassLoaderPolicy policy); void registerService(ServiceNameVersion serviceIdentifier); void unregisterService(ServiceNameVersion service); Class<?> getServiceClass(ServiceNameVersion service); static final String getPackageName(String className); void addRepository(Repository repository); }### Answer: @Test public void testPackageName() { assertEquals("my.package", ClassManager.getPackageName("my.package.Class")); try { ClassManager.getPackageName("teststring"); fail("IllegalArgumentException should have been thrown"); } catch (IllegalArgumentException e) { } }
### Question: ClassLoaderPolicy { public boolean canLoad(String className) { if (deniedPaths.contains("")) { return false; } String[] split = className.split("\\."); String current = ""; for (String part : split) { current += (current.equals("")) ? part : ("." + part); if (deniedPaths.contains(current)) { return false; } } if (allowedPaths.contains("")) { return true; } current = ""; for (String part : split) { current += (current.equals("")) ? part : ("." + part); if (allowedPaths.contains(current)) { return true; } } return false; } boolean canLoad(String className); }### Answer: @Test public void test() { ClassLoaderPolicy policy = new TestPolicy(); assertFalse(policy.canLoad("notallowed")); assertTrue(policy.canLoad("package")); assertTrue(policy.canLoad("package.sub")); assertFalse(policy.canLoad("package2")); assertTrue(policy.canLoad("package2.sub")); assertTrue(policy.canLoad("package3.sub1")); assertTrue(policy.canLoad("package3.sub1.sub")); assertFalse(policy.canLoad("package3.sub")); assertFalse(policy.canLoad("package3.sub.sub")); ClassLoaderPolicy policy2 = new TestPolicy2(); assertTrue(policy2.canLoad("package2")); assertFalse(policy2.canLoad("package")); }
### Question: LibraryVersion { public boolean equals(LibraryVersion v) { return v.toString().equals(this.toString()); } LibraryVersion(String version); LibraryVersion(int major, int minor, int sub, int build); LibraryVersion(int major, int minor, int sub); LibraryVersion(int major, int minor); LibraryVersion(int major); boolean equals(LibraryVersion v); @Override boolean equals(Object o); @Override int hashCode(); int getMinor(); int getMajor(); int getSub(); int getBuild(); @Override String toString(); }### Answer: @Test public void testEquality() { LibraryVersion testee1 = new LibraryVersion("10.0.1-1234"); LibraryVersion testee2 = new LibraryVersion(10, 0, 1, 1234); assertTrue(testee1.equals(testee2)); assertEquals(testee1, testee2); assertFalse(new LibraryVersion("10.1.1-1234").equals(new LibraryVersion(10, 1, 1, 123))); assertFalse(new LibraryVersion("10.1.1-1234").equals(new LibraryVersion(10, 1, 1))); assertEquals(new LibraryVersion("10.0.1-1234"), "10.0.1-1234"); }
### Question: RESTService extends Service { public final String getSwagger() throws JsonProcessingException { Swagger swagger = new Reader(new Swagger()).read(this.application.getClasses()); return Json.mapper().writeValueAsString(swagger); } RESTService(); final RESTResponse handle(URI baseUri, URI requestUri, String method, byte[] body, Map<String, List<String>> headers); final String getSwagger(); @Override final String getAlias(); }### Answer: @Test public void testSwagger() throws JsonProcessingException { String response = testee.getSwagger(); assertTrue(response.contains("getHello")); }
### Question: LibraryVersion { @Override public String toString() { String result = "" + major; if (minor != null) { result += "." + minor; if (sub != null) result += "." + sub; } if (build != null) result += "-" + build; return result; } LibraryVersion(String version); LibraryVersion(int major, int minor, int sub, int build); LibraryVersion(int major, int minor, int sub); LibraryVersion(int major, int minor); LibraryVersion(int major); boolean equals(LibraryVersion v); @Override boolean equals(Object o); @Override int hashCode(); int getMinor(); int getMajor(); int getSub(); int getBuild(); @Override String toString(); }### Answer: @Test public void testStringRepresentation() { assertEquals("10.0.1-1234", new LibraryVersion(10, 0, 1, 1234).toString()); assertEquals("10.0-1234", new LibraryVersion("10.0-1234").toString()); assertEquals("10-1234", new LibraryVersion("10-1234").toString()); assertEquals("10.0.1", new LibraryVersion(10, 0, 1).toString()); assertEquals("10.1", new LibraryVersion(10, 1).toString()); assertEquals("10", new LibraryVersion(10).toString()); }
### Question: LibraryIdentifier { public boolean equals(LibraryIdentifier i) { return this.toString().equals(i.toString()); } LibraryIdentifier(String name); LibraryIdentifier(String name, String version); LibraryIdentifier(String name, LibraryVersion version); static LibraryIdentifier fromFilename(String filename); LibraryVersion getVersion(); String getName(); @Override String toString(); boolean equals(LibraryIdentifier i); @Override boolean equals(Object o); @Override int hashCode(); static final String MANIFEST_LIBRARY_NAME_ATTRIBUTE; static final String MANIFEST_LIBRARY_VERSION_ATTRIBUTE; }### Answer: @Test public void testEquality() { assertEquals(new LibraryIdentifier("testname;version=\"1.0.1-22\""), "testname;version=\"1.0.1-22\""); assertFalse(new LibraryIdentifier("testname;version=\"1.0.1-22\"").equals("tstname;version=\"1.0.1-22\"")); }
### Question: LoadedLibrary { public static String resourceToClassName(String entryName) { if (!entryName.endsWith(".class")) { throw new IllegalArgumentException("This is not a class file!"); } return entryName.replace('/', '.').substring(0, entryName.length() - 6); } LoadedLibrary(String libraryIdentifier); LoadedLibrary(LibraryIdentifier lib); LibraryIdentifier getLibraryIdentifier(); abstract URL getResourceAsUrl(String name); String getResourceAsString(String resourceName); byte[] getResourceAsBinary(String resourceName); LibraryIdentifier getIdentifier(); static String classToResourceName(String className); static String resourceToClassName(String entryName); }### Answer: @Test public void testResourceToClassName() { assertEquals("test.bla.Class", LoadedLibrary.resourceToClassName("test/bla/Class.class")); try { LoadedLibrary.resourceToClassName("test.clas"); fail("IllegalArgumentException should have been thrown"); } catch (IllegalArgumentException e) { } }
### Question: LoadedLibrary { public static String classToResourceName(String className) { return className.replace('.', '/') + ".class"; } LoadedLibrary(String libraryIdentifier); LoadedLibrary(LibraryIdentifier lib); LibraryIdentifier getLibraryIdentifier(); abstract URL getResourceAsUrl(String name); String getResourceAsString(String resourceName); byte[] getResourceAsBinary(String resourceName); LibraryIdentifier getIdentifier(); static String classToResourceName(String className); static String resourceToClassName(String entryName); }### Answer: @Test public void testClassToResourceName() { assertEquals("test/bla/Class.class", LoadedLibrary.classToResourceName("test.bla.Class")); assertEquals("Class.class", LoadedLibrary.classToResourceName("Class")); }
### Question: FileSystemRepository implements Repository { public static long getLastModified(File dir, boolean recursive) { File[] files = dir.listFiles(); if (files == null \|\| files.length == 0) { return dir.lastModified(); } long lastModified = 0; for (File f : files) { if (f.isDirectory() && recursive) { long ll = getLastModified(f, recursive); if (lastModified < ll) { lastModified = ll; } } else { if (lastModified < f.lastModified()) { lastModified = f.lastModified(); } } } return lastModified; } FileSystemRepository(String directory); FileSystemRepository(String directory, boolean recursive); FileSystemRepository(String[] directories); FileSystemRepository(String[] directories, boolean recursive); FileSystemRepository(Iterable<String> directories, boolean recursive); @Override LoadedLibrary findLibrary(String name); @Override LoadedLibrary findLibrary(LibraryIdentifier lib); String[] getAvailableVersions(String libraryName); Collection<LibraryVersion> getAvailableVersionSet(String libraryName); String[] getAllLibraries(); Collection<String> getLibraryCollection(); static long getLastModified(File dir, boolean recursive); @Override String toString(); }### Answer: @Test public void testGetLastModified() throws InterruptedException { File f = new File("export" + File.separator + "jars" + File.separator); long date1 = FileSystemRepository.getLastModified(f, true); assertTrue(date1 > 0); Thread.sleep(2000); new File("export" + File.separator + "jars" + File.separator + "i5.las2peer.classLoaders.testPackage1-1.0.jar") .setLastModified(System.currentTimeMillis()); long date2 = FileSystemRepository.getLastModified(f, true); assertTrue(date1 < date2); long date3 = FileSystemRepository.getLastModified(f, true); assertTrue(date2 == date3); }
### Question: ServiceAgentGenerator { public static void main(String argv[]) { if (argv.length != 2) { System.err.println( "usage: java i5.las2peer.tools.ServiceAgentGenerator [service class]@[service version] [passphrase]"); return; } else if (argv[0].length() < PW_MIN_LENGTH) { System.err.println("the password needs to be at least " + PW_MIN_LENGTH + " signs long, but only " + argv[0].length() + " given"); return; } try { ServiceAgentImpl agent = ServiceAgentImpl.createServiceAgent(ServiceNameVersion.fromString(argv[0]), argv[1]); System.out.print(agent.toXmlString()); } catch (Exception e) { System.err.println("unable to generate new agent: " + e); } } static void main(String argv[]); }### Answer: @Test public void testMainUsage() { ServiceAgentGenerator.main(new String[0]); assertTrue(("" + standardError.toString()).contains("usage:")); assertEquals("", standardOut.toString()); } @Test public void testMainNormal() { String className = "[email protected]"; ServiceAgentGenerator.main(new String[] { className, "mypass" }); assertEquals("", standardError.toString()); String output = standardOut.toString(); assertTrue(output.contains("serviceclass=\"" + className + "\"")); }
### Question: AnonymousAgentImpl extends AgentImpl implements AnonymousAgent { @Override public boolean isLocked() { return false; } private AnonymousAgentImpl(); static AnonymousAgentImpl getInstance(); @Override String toXmlString(); @Override void receiveMessage(Message message, AgentContext c); @Override void unlockPrivateKey(SecretKey key); @Override void encryptPrivateKey(SecretKey key); @Override boolean isLocked(); @Override String getIdentifier(); @Override PublicKey getPublicKey(); @Override SecretKey decryptSymmetricKey(byte[] crypted); @Override Signature createSignature(); @Override byte[] signContent(byte[] plainData); @Override boolean equals(Object other); }### Answer: @Test public void testCreation() { assertFalse(anonymousAgent.isLocked()); }
### Question: AnonymousAgentImpl extends AgentImpl implements AnonymousAgent { @Override public String getIdentifier() { return AnonymousAgent.IDENTIFIER; } private AnonymousAgentImpl(); static AnonymousAgentImpl getInstance(); @Override String toXmlString(); @Override void receiveMessage(Message message, AgentContext c); @Override void unlockPrivateKey(SecretKey key); @Override void encryptPrivateKey(SecretKey key); @Override boolean isLocked(); @Override String getIdentifier(); @Override PublicKey getPublicKey(); @Override SecretKey decryptSymmetricKey(byte[] crypted); @Override Signature createSignature(); @Override byte[] signContent(byte[] plainData); @Override boolean equals(Object other); }### Answer: @Test public void testOperations() throws AgentNotFoundException, AgentException, InternalSecurityException { AnonymousAgent a = (AnonymousAgent) node.getAgent(AnonymousAgent.IDENTIFIER); assertEquals(a.getIdentifier(), AnonymousAgent.IDENTIFIER); a = (AnonymousAgent) node.getAgent(AnonymousAgent.LOGIN_NAME); assertEquals(a.getIdentifier(), AnonymousAgent.IDENTIFIER); try { node.storeAgent(anonymousAgent); fail("Exception expected"); } catch (AgentException e) { } }
### Question: ServiceHelper { public static Object execute(Service service, String method) throws ServiceMethodNotFoundException, IllegalArgumentException, IllegalAccessException, InvocationTargetException { return execute(service, method, new Object[0]); } static Class<?> getWrapperClass(Class<?> c); static boolean isWrapperClass(Class<?> c); static boolean isSubclass(Class<?> subClass, Class<?> superClass); static Class<?> getUnwrappedClass(Class<?> c); static Object execute(Service service, String method); static Object execute(Service service, String method, Object... parameters); static Method searchMethod(Class<? extends Service> serviceClass, String methodName, Object[] params); static String getParameterString(Object[] params); }### Answer: @Test public void testInvocation() throws SecurityException, IllegalArgumentException, ServiceMethodNotFoundException, IllegalAccessException, InvocationTargetException, InternalSecurityException { TestService testee = new TestService(); assertEquals(10, ServiceHelper.execute(testee, "getInt")); assertEquals(4, ServiceHelper.execute(testee, "inc", 2)); assertEquals(4, ServiceHelper.execute(testee, "inc", new Integer(2))); } @Test public void testSubclassParam() throws SecurityException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, InternalSecurityException, ServiceMethodNotFoundException { TestService testee = new TestService(); assertEquals("testnachricht", ServiceHelper.execute(testee, "subclass", new SecurityException("testnachricht"))); } @Test public void testExceptions() throws SecurityException, IllegalArgumentException, IllegalAccessException, InvocationTargetException, InternalSecurityException { TestService testee = new TestService(); try { ServiceHelper.execute(testee, "privateMethod"); fail("ServiceMethodNotFoundException expected"); } catch (ServiceMethodNotFoundException e) { } try { ServiceHelper.execute(testee, "protectedMethod"); fail("ServiceMethodNotFoundException expected"); } catch (ServiceMethodNotFoundException e) { } try { ServiceHelper.execute(testee, "staticMethod"); fail("ServiceMethodNotFoundException expected"); } catch (ServiceMethodNotFoundException e) { } }
### Question: SimpleTools { public static String join(Object[] objects, String glue) { if (objects == null) { return ""; } return SimpleTools.join(Arrays.asList(objects), glue); } static long longHash(String s); static String createRandomString(int length); static String join(Object[] objects, String glue); static String join(Iterable<?> objects, String glue); static String repeat(String string, int count); static String repeat(Object o, int count); static byte[] toByteArray(InputStream is); static String byteToHexString(byte[] bytes); static int getSystemDefinedPort(); static final String sRandomStringCharSet; }### Answer: @Test public void testJoin() { assertEquals("", SimpleTools.join((Object[]) null, "abc")); assertEquals("", SimpleTools.join(new Object[0], "dkefde")); assertEquals("a, b, c", SimpleTools.join(new Object[] { "a", 'b', "c" }, ", ")); assertEquals("10.20.30", SimpleTools.join(new Integer[] { 10, 20, 30 }, ".")); }
### Question: SimpleTools { public static String repeat(String string, int count) { if (string == null) { return null; } else if (string.isEmpty() \|\| count <= 0) { return ""; } StringBuffer result = new StringBuffer(); for (int i = 0; i < count; i++) { result.append(string); } return result.toString(); } static long longHash(String s); static String createRandomString(int length); static String join(Object[] objects, String glue); static String join(Iterable<?> objects, String glue); static String repeat(String string, int count); static String repeat(Object o, int count); static byte[] toByteArray(InputStream is); static String byteToHexString(byte[] bytes); static int getSystemDefinedPort(); static final String sRandomStringCharSet; }### Answer: @Test public void testRepeat() { assertEquals("", SimpleTools.repeat("", 11)); assertEquals("", SimpleTools.repeat("adwdw", 0)); assertEquals("", SimpleTools.repeat("adwdw", -10)); assertNull(SimpleTools.repeat(null, 100)); assertEquals("xxxx", SimpleTools.repeat("x", 4)); assertEquals("101010", SimpleTools.repeat(10, 3)); }
### Question: Utils { public static String createSlug(final String slug) { return slug.replaceAll("[^\\w\\s]", "").trim().toLowerCase().replaceAll("\\W+", "-"); } static void print(String title, String message, int type); static void print(final String title, final int message); static void print(final String title, final String message); static void showSnackbar(final CoordinatorLayout layout, final Context context, final String message); static void showSnackbar(final CoordinatorLayout layout, final Context context, final String message, final boolean isError); static void showSnackbar(final CoordinatorLayout layout, final Context context, final int message); static void showSnackbar(final CoordinatorLayout layout, final Context context, final int message, final boolean isError); static void showSnackbar(final CoordinatorLayout layout, final Context context, final String message, final int action); static void showSnackbar(final CoordinatorLayout layout, final Context context, final int message, final int action); static String createSlug(final String slug); static boolean isNavBarOnBottom(@NonNull Context context); static @CheckResult @ColorInt int modifyAlpha(@ColorInt int color, @IntRange(from = 0, to = 255) int alpha); static @CheckResult @ColorInt int modifyAlpha(@ColorInt int color, @FloatRange(from = 0f, to = 1f) float alpha); static String getDateAgo(final Context context, final String isoDate); static boolean isInternetConnected(final Context context); @SuppressLint("PrivateApi") static Boolean hasNavigationBar(final String TAG, final Resources resources); static void share(final String TAG, final Context context, final String name, final String title, final String url); }### Answer: @Test public void createSlug() { String input = "This is a title"; String expected = "this-is-a-title"; String output = Utils.createSlug(input); assertEquals(expected,output); }
### Question: PlaygroundApplication { public static void main(String[] args) { SpringApplication.run(PlaygroundApplication.class, args); } static void main(String[] args); }### Answer: @Test public void main() throws Exception { PlaygroundApplication playgroundApplication = new PlaygroundApplication(); playgroundApplication.main(new String[]{}); }
### Question: ProductService { public TdBProduct getProductInfo(Long productId) { TdBProduct tdBProduct = tdBProductRepository.findOne(productId); if (tdBProduct == null) { throw new ResourceNotFoundException(String.format("不存在 productId=%s", productId)); } return tdBProduct; } TdBProduct getProductInfo(Long productId); }### Answer: @Test public void getProductInfo() throws Exception { Long productId = 99999830L; given(tdBProductRepository.findOne(productId)).willReturn(mockDiscnt(productId)); TdBProduct productInfo = productService.getProductInfo(99999830L); assertThat(productInfo.getProductId()).isEqualTo(productId); } @Test(expected = ResourceNotFoundException.class) public void getProductInfoResourceNotFoundException() throws Exception { Long productId = 1L; productService.getProductInfo(99999830L); }
### Question: RootController { @RequestMapping(value = {"/"}, method = RequestMethod.GET) public String rootRedirect() { return "index"; } @RequestMapping(value = {"/"}, method = RequestMethod.GET) String rootRedirect(); }### Answer: @Test public void rootRedirect() throws Exception { ResponseEntity<String> result = restTemplate.exchange("/", HttpMethod.GET, new HttpEntity(null), String.class); logger.info(result.toString()); assertThat(result.getStatusCode()).isEqualTo(HttpStatus.OK); }
### Question: ProductController { @Cacheable("getProductInfo") @HystrixCommand( fallbackMethod = "", ignoreExceptions = {Exception.class} ) @ApiOperation(value = "查询产品配置") @RequestMapping(value = "/{productId}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_UTF8_VALUE) public ProductDTO getProductInfo(@ApiParam(value = "产品编码", defaultValue = "99999830", required = true) @PathVariable Long productId) { TdBProduct productInfo = productService.getProductInfo(productId); return staticModelMapperComponent.productEntityToDTO(productInfo); } @Cacheable("getProductInfo") @HystrixCommand( fallbackMethod = "", // Use Exception Handler ignoreExceptions = {Exception.class} ) @ApiOperation(value = "查询产品配置") @RequestMapping(value = "/{productId}", method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_UTF8_VALUE) ProductDTO getProductInfo(@ApiParam(value = "产品编码", defaultValue = "99999830", required = true) @PathVariable Long productId); }### Answer: @Test public void getProductInfo() throws Exception { ResponseEntity<ProductDTO> result = restTemplate.getForEntity(baseurl + "/products/99999830", ProductDTO.class); logger.info(result.toString()); assertThat(result.getStatusCode()).isEqualTo(HttpStatus.OK); assertThat(result.getBody().getProductId()).isEqualTo(99999830L); }
### Question: SemanticVersion implements Comparable<SemanticVersion>, Serializable { @Override public String toString() { StringBuilder ret = new StringBuilder(); ret.append(major); ret.append('.'); ret.append(minor); ret.append('.'); ret.append(patch); if (qualifier != null) { ret.append('-'); ret.append(qualifier); } return ret.toString(); } SemanticVersion(); SemanticVersion(int major, int minor, int patch); SemanticVersion(int major, int minor, int patch, String qualifier); SemanticVersion(String version); boolean isUpdateFor(SemanticVersion v); boolean isSameOrNewer(SemanticVersion v); boolean isSame(SemanticVersion v); boolean isCompatibleUpdateFor(SemanticVersion v); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object other); @Override int compareTo(SemanticVersion v); String getAsString(); void setAsString(String version); public int major; public int minor; public int patch; public String qualifier; }### Answer: @Test public void testParsePlain() throws ParseException { SemanticVersion v = new SemanticVersion("1.2.3"); assertEquals(1, v.major); assertEquals(2, v.minor); assertEquals(3, v.patch); assertEquals("1.2.3", v.toString()); v = new SemanticVersion("11.22.33"); assertEquals(11, v.major); assertEquals(22, v.minor); assertEquals(33, v.patch); assertEquals("11.22.33", v.toString()); v = new SemanticVersion("11.22.33-SNAPSHOT"); assertEquals(11, v.major); assertEquals(22, v.minor); assertEquals(33, v.patch); assertEquals("SNAPSHOT", v.qualifier); assertEquals("11.22.33-SNAPSHOT", v.toString()); }
### Question: NzbGeek extends Newznab { @Override protected String cleanupQuery(String query) { String[] split = query.split(" "); if (query.split(" ").length > 6) { query = Joiner.on(" ").join(Arrays.copyOfRange(split, 0, 6)); } return query.replace("\"", ""); } }### Answer: @Test public void shouldNotUseMoreThan6WordsForNzbGeek() throws Exception { String query = "1 2 3 4 5 6 7 8 9"; assertThat(testee.cleanupQuery(query), is("1 2 3 4 5 6")); }
### Question: IndexerWebAccess { @SuppressWarnings("unchecked") public <T> T get(URI uri, IndexerConfig indexerConfig) throws IndexerAccessException { return get(uri, indexerConfig, null); } @SuppressWarnings("unchecked") T get(URI uri, IndexerConfig indexerConfig); @SuppressWarnings("unchecked") T get(URI uri, IndexerConfig indexerConfig, Class responseType); }### Answer: @Test public void shouldUseIndexerUserAgent() throws Exception{ testee.get(new URI("http: Map<String, String> headers = headersCaptor.getValue(); assertThat(headers).contains(entry("User-Agent", "indexerUa")); } @Test public void shouldUseGlobalUserAgentIfNoIndexerUaIsSet() throws Exception{ indexerConfig.setUserAgent(null); testee.get(new URI("http: Map<String, String> headers = headersCaptor.getValue(); assertThat(headers).contains(entry("User-Agent", "globalUa")); } @Test public void shouldUseIndexerTimeout() throws Exception{ testee.get(new URI("http: assertThat(timeoutCaptor.getValue()).isEqualTo(10); } @Test public void shouldUseGlobalTimeoutNoIndexerTimeoutIsSet() throws Exception{ indexerConfig.setTimeout(null); testee.get(new URI("http: assertThat(timeoutCaptor.getValue()).isEqualTo(100); }
### Question: TmdbHandler { public TmdbSearchResult getInfos(String value, MediaIdType idType) throws InfoProviderException { if (idType == MediaIdType.MOVIETITLE) { return fromTitle(value, null); } if (idType == MediaIdType.IMDB) { return fromImdb(value); } if (idType == MediaIdType.TMDB) { return fromTmdb(value); } throw new IllegalArgumentException("Unable to get infos from " + idType); } TmdbSearchResult getInfos(String value, MediaIdType idType); List<TmdbSearchResult> search(String title, Integer year); }### Answer: @Test public void imdbToTmdb() throws Exception { TmdbSearchResult result = testee.getInfos("tt5895028", MediaIdType.IMDB); assertThat(result.getTmdbId(), is("407806")); assertThat(result.getTitle(), is("13th")); } @Test public void tmdbToImdb() throws Exception { TmdbSearchResult result = testee.getInfos("407806", MediaIdType.TMDB); assertThat(result.getImdbId(), is("tt5895028")); assertThat(result.getTitle(), is("13th")); }
### Question: TmdbHandler { TmdbSearchResult fromTitle(String title, Integer year) throws InfoProviderException { Movie movie = getMovieByTitle(title, year); TmdbSearchResult result = getSearchResultFromMovie(movie); return result; } TmdbSearchResult getInfos(String value, MediaIdType idType); List<TmdbSearchResult> search(String title, Integer year); }### Answer: @Test public void fromTitle() throws Exception { TmdbSearchResult result = testee.getInfos("gladiator", MediaIdType.MOVIETITLE); assertThat(result.getImdbId(), is("tt0172495")); result = testee.fromTitle("gladiator", 1992); assertThat(result.getImdbId(), is("tt0104346")); }
### Question: UpdateManager implements InitializingBean { public boolean isUpdateAvailable() { try { return getLatestVersion().isUpdateFor(currentVersion) && !latestVersionIgnored() && !latestVersionBlocked() && latestVersionFinalOrPreEnabled(); } catch (UpdateException e) { logger.error("Error while checking if new version is available", e); return false; } } UpdateManager(); boolean isUpdateAvailable(); boolean latestVersionFinalOrPreEnabled(); boolean latestVersionIgnored(); boolean latestVersionBlocked(); String getLatestVersionString(); String getCurrentVersionString(); void ignore(String version); List<ChangelogVersionEntry> getChangesSinceCurrentVersion(); List<ChangelogVersionEntry> getAllVersionChangesUpToCurrentVersion(); List<ChangelogVersionEntry> getAutomaticUpdateVersionHistory(); void installUpdate(boolean isAutomaticUpdate); void exitWithReturnCode(final int returnCode); @Override void afterPropertiesSet(); PackageInfo getPackageInfo(); static final int SHUTDOWN_RETURN_CODE; static final int UPDATE_RETURN_CODE; static final int RESTART_RETURN_CODE; static final int RESTORE_RETURN_CODE; static final String KEY; }### Answer: @Test public void testThatChecksForUpdateAvailable() throws Exception { assertTrue(testee.isUpdateAvailable()); testee.currentVersion = new SemanticVersion("v2.0.0"); assertFalse(testee.isUpdateAvailable()); } @Test public void testThatChecksForUpdateAvailableWithPrerelease() throws Exception { assertTrue(testee.isUpdateAvailable()); configProviderMock.getBaseConfig().getMain().setUpdateToPrereleases(true); testee.currentVersion = new SemanticVersion("v2.3.4"); assertFalse(testee.isUpdateAvailable()); }
### Question: UpdateManager implements InitializingBean { public String getLatestVersionString() throws UpdateException { return getLatestVersion().toString(); } UpdateManager(); boolean isUpdateAvailable(); boolean latestVersionFinalOrPreEnabled(); boolean latestVersionIgnored(); boolean latestVersionBlocked(); String getLatestVersionString(); String getCurrentVersionString(); void ignore(String version); List<ChangelogVersionEntry> getChangesSinceCurrentVersion(); List<ChangelogVersionEntry> getAllVersionChangesUpToCurrentVersion(); List<ChangelogVersionEntry> getAutomaticUpdateVersionHistory(); void installUpdate(boolean isAutomaticUpdate); void exitWithReturnCode(final int returnCode); @Override void afterPropertiesSet(); PackageInfo getPackageInfo(); static final int SHUTDOWN_RETURN_CODE; static final int UPDATE_RETURN_CODE; static final int RESTART_RETURN_CODE; static final int RESTORE_RETURN_CODE; static final String KEY; }### Answer: @Test public void shouldGetLatestReleaseFromGithub() throws Exception { String latestVersionString = testee.getLatestVersionString(); assertEquals("2.0.0", latestVersionString); testee.getLatestVersionString(); }
### Question: CategoryProvider implements InitializingBean { public static boolean checkCategoryMatchingMainCategory(int cat, int possibleMainCat) { return possibleMainCat % 1000 == 0 && cat / 1000 == possibleMainCat / 1000; } CategoryProvider(); @Override void afterPropertiesSet(); @org.springframework.context.event.EventListener void handleNewConfigEvent(ConfigChangedEvent newConfig); List<Category> getCategories(); void setCategories(List<Category> categories); Category getByInternalName(String name); Category getNotAvailable(); Category fromSearchNewznabCategories(String cats); Optional<Category> fromSubtype(Subtype subtype); Category fromSearchNewznabCategories(List<Integer> cats, Category defaultCategory); Category fromResultNewznabCategories(List<Integer> cats); static boolean checkCategoryMatchingMainCategory(int cat, int possibleMainCat); Category getMatchingCategoryOrMatchingMainCategory(List<Integer> cats, Category defaultCategory); static final Category naCategory; }### Answer: @Test public void testcheckCategoryMatchingMainCategory() { assertThat(testee.checkCategoryMatchingMainCategory(5030, 5000), is(true)); assertThat(testee.checkCategoryMatchingMainCategory(5000, 5000), is(true)); assertThat(testee.checkCategoryMatchingMainCategory(4030, 5000), is(false)); assertThat(testee.checkCategoryMatchingMainCategory(4000, 5000), is(false)); assertThat(testee.checkCategoryMatchingMainCategory(4030, 4030), is(false)); }
### Question: CategoryProvider implements InitializingBean { public Optional<Category> fromSubtype(Subtype subtype) { return categories.stream().filter(x -> x.getSubtype() == subtype).findFirst(); } CategoryProvider(); @Override void afterPropertiesSet(); @org.springframework.context.event.EventListener void handleNewConfigEvent(ConfigChangedEvent newConfig); List<Category> getCategories(); void setCategories(List<Category> categories); Category getByInternalName(String name); Category getNotAvailable(); Category fromSearchNewznabCategories(String cats); Optional<Category> fromSubtype(Subtype subtype); Category fromSearchNewznabCategories(List<Integer> cats, Category defaultCategory); Category fromResultNewznabCategories(List<Integer> cats); static boolean checkCategoryMatchingMainCategory(int cat, int possibleMainCat); Category getMatchingCategoryOrMatchingMainCategory(List<Integer> cats, Category defaultCategory); static final Category naCategory; }### Answer: @Test public void shouldFindBySubtype() { Optional<Category> animeOptional = testee.fromSubtype(Subtype.ANIME); assertThat(animeOptional.isPresent(), is(true)); assertThat(animeOptional.get().getName(), is("7020,8010")); Optional<Category> magazineOptional = testee.fromSubtype(Subtype.MAGAZINE); assertThat(magazineOptional.isPresent(), is(false)); }
### Question: NewznabParameters { @Override public int hashCode() { return Objects.hashCode(apikey, t, q, cat, rid, tvdbid, tvmazeid, traktId, imdbid, tmdbid, season, ep, author, title, offset, limit, minage, maxage, minsize, maxsize, id, raw, o, cachetime, genre, attrs, extended, password); } @Override String toString(); @Override boolean equals(Object o1); @Override int hashCode(); int cacheKey(NewznabResponse.SearchType searchType); }### Answer: @Test public void testHashCode() throws Exception { NewznabParameters testee1 = new NewznabParameters(); testee1.setQ("q"); NewznabParameters testee2 = new NewznabParameters(); testee2.setQ("q"); assertEquals(testee1.cacheKey(NewznabResponse.SearchType.TORZNAB), testee2.cacheKey(NewznabResponse.SearchType.TORZNAB)); assertNotEquals(testee1.cacheKey(NewznabResponse.SearchType.TORZNAB), testee2.cacheKey(NewznabResponse.SearchType.NEWZNAB)); testee2.setQ("anotherQ"); assertNotEquals(testee1.cacheKey(NewznabResponse.SearchType.TORZNAB), testee2.cacheKey(NewznabResponse.SearchType.TORZNAB)); }
### Question: DuplicateDetector { protected boolean testForDuplicateAge(SearchResultItem result1, SearchResultItem result2, float duplicateAgeThreshold) { Instant date1 = result1.getBestDate(); Instant date2 = result2.getBestDate(); if (date1 == null \|\| date2 == null) { logger.debug(LoggingMarkers.DUPLICATES, "At least one result has no usenet date and no pub date"); return false; } boolean isSameAge = Math.abs(date1.getEpochSecond() - date2.getEpochSecond()) / (60 * 60) <= duplicateAgeThreshold; logger.debug(LoggingMarkers.DUPLICATES, "Same age: {}", isSameAge); return isSameAge; } DuplicateDetectionResult detectDuplicates(Set<SearchResultItem> results); }### Answer: @Test public void shouldUseUsenetDateForComparison() throws Exception { SearchResultItem item1 = new SearchResultItem(); setValues(item1, "1", "poster1", "group", Instant.now()); item1.setPubDate(Instant.now().minus(100, ChronoUnit.DAYS)); SearchResultItem item2 = new SearchResultItem(); setValues(item2, "2", "poster1", "group", Instant.now()); item2.setPubDate(Instant.now().minus(300, ChronoUnit.DAYS)); item1.setUsenetDate(Instant.now()); item2.setUsenetDate(Instant.now()); assertThat(testee.testForDuplicateAge(item1, item2, 1F)).isTrue(); item2.setUsenetDate(null); assertThat(testee.testForDuplicateAge(item1, item2, 1F)).isFalse(); }
### Question: DownloadStatusUpdater { @EventListener public void onNzbDownloadEvent(FileDownloadEvent downloadEvent) { if (!configProvider.getBaseConfig().getMain().isKeepHistory()) { return; } lastDownload = Instant.now(); queueCheckEnabled = true; historyCheckEnabled = true; logger.debug(LoggingMarkers.DOWNLOAD_STATUS_UPDATE, "Received download event. Will enable status updates for the next {} minutes", (MIN_SECONDS_SINCE_LAST_DOWNLOAD_TO_CHECK_STATUSES / 60)); } @HydraTask(configId = "downloadHistoryCheck", name = "Download history check", interval = TEN_MINUTES_MS) @Transactional void checkHistoryStatus(); @HydraTask(configId = "downloadQueueCheck", name = "Download queue check", interval = TEN_SECONDS_MS) @Transactional void checkQueueStatus(); @EventListener void onNzbDownloadEvent(FileDownloadEvent downloadEvent); }### Answer: @Test public void shouldSetEnabledOnDownloadEvent() { testee.queueCheckEnabled = false; testee.lastDownload = null; testee.onNzbDownloadEvent(new FileDownloadEvent(new FileDownloadEntity(), new SearchResultEntity())); assertThat(testee.queueCheckEnabled).isTrue(); assertThat(testee.lastDownload).isNotNull(); }
### Question: RssItemBuilder { public static RssItemBuilder builder() { RssItemBuilder builder = new RssItemBuilder(); return builder; } private RssItemBuilder(); static RssItemBuilder builder(); static RssItemBuilder builder(String title); RssItemBuilder title(String title); RssItemBuilder link(String link); RssItemBuilder size(long size); RssItemBuilder pubDate(Instant pubDate); RssItemBuilder rssGuid(NewznabXmlGuid rssGuid); RssItemBuilder description(String description); RssItemBuilder comments(String comments); RssItemBuilder category(String category); RssItemBuilder grabs(Integer grabs); RssItemBuilder newznabAttributes(List<NewznabAttribute> newznabAttributes); RssItemBuilder torznabAttributes(List<NewznabAttribute> torznabAttributes); RssItemBuilder enclosure(NewznabXmlEnclosure enclosure); RssItemBuilder hasNfo(boolean hasNfo); RssItemBuilder poster(String poster); RssItemBuilder group(String group); RssItemBuilder linksFromBaseUrl(String baseUrl); RssItemBuilder categoryNewznab(String... categories); NewznabXmlItem build(); }### Answer: @Test public void testBuilder() { NewznabXmlItem item = RssItemBuilder.builder("title") .group("group") .poster("poster") .size(1000L) .category("category") .categoryNewznab("5000") .description("desc") .link("link") .hasNfo(true) .grabs(10).build(); Map<String, String> attributes = item.getNewznabAttributes().stream().collect(Collectors.toMap(NewznabAttribute::getName, NewznabAttribute::getValue)); assertEquals("group", attributes.get("group")); assertEquals("poster", attributes.get("poster")); assertEquals("5000", attributes.get("category")); assertEquals("1", attributes.get("nfo")); assertEquals(Long.valueOf(1000), item.getEnclosure().getLength()); assertEquals("desc", item.getDescription()); assertEquals("category", item.getCategory()); assertEquals("link", item.getEnclosure().getUrl()); }
### Question: IndexerForSearchSelector { protected boolean checkIndexerSelectedByUser(Indexer indexer) { boolean indexerNotSelectedByUser = (searchRequest.getIndexers().isPresent() && !searchRequest.getIndexers().get().isEmpty()) && !searchRequest.getIndexers().get().contains(indexer.getName()); if (indexerNotSelectedByUser) { logger.info(String.format("Not using %s because it was not selected by the user", indexer.getName())); notSelectedIndersWithReason.put(indexer, "Not selected by the user"); return false; } return true; } IndexerForSearchSelection pickIndexers(SearchRequest searchRequest); static final Pattern SCHEDULER_PATTERN; }### Answer: @Test public void shouldCheckIfSelectedByUser() { when(searchModuleProviderMock.getIndexers()).thenReturn(Arrays.asList(indexer)); when(searchRequest.getSource()).thenReturn(SearchSource.INTERNAL); when(searchRequest.getIndexers()).thenReturn(Optional.of(Sets.newSet("anotherIndexer"))); assertFalse(testee.checkIndexerSelectedByUser(indexer)); when(searchRequest.getSource()).thenReturn(SearchSource.API); assertFalse(testee.checkIndexerSelectedByUser(indexer)); when(searchRequest.getIndexers()).thenReturn(Optional.of(Sets.newSet("indexer"))); when(searchRequest.getSource()).thenReturn(SearchSource.INTERNAL); assertTrue(testee.checkIndexerSelectedByUser(indexer)); when(searchRequest.getSource()).thenReturn(SearchSource.API); assertTrue(testee.checkIndexerSelectedByUser(indexer)); }
### Question: CategoryConverter implements AttributeConverter<Category, String> { @Override public String convertToDatabaseColumn(Category category) { if (category == null) { return null; } return category.getName(); } @Autowired void setCategoryProvider(CategoryProvider categoryProvider); @Override String convertToDatabaseColumn(Category category); @Override Category convertToEntityAttribute(String categoryName); }### Answer: @Test public void convertToDatabaseColumn() throws Exception { Category category = new Category(); category.setName("name"); assertThat(testee.convertToDatabaseColumn(category), is("name")); }
### Question: CategoryConverter implements AttributeConverter<Category, String> { @Override public Category convertToEntityAttribute(String categoryName) { return categoryProvider.getByInternalName(categoryName); } @Autowired void setCategoryProvider(CategoryProvider categoryProvider); @Override String convertToDatabaseColumn(Category category); @Override Category convertToEntityAttribute(String categoryName); }### Answer: @Test public void convertToEntityAttribute() throws Exception { Category category = new Category(); when(categoryProviderMock.getByInternalName("name")).thenReturn(category); assertThat(testee.convertToEntityAttribute("name"), is(category)); }
### Question: IndexerForSearchSelector { protected boolean checkIndexerStatus(Indexer indexer) { if (indexer.getConfig().getState() == IndexerConfig.State.DISABLED_SYSTEM_TEMPORARY) { if (indexer.getConfig().getDisabledUntil() == null \|\| Instant.ofEpochMilli(indexer.getConfig().getDisabledUntil()).isBefore(clock.instant())) { return true; } String message = String.format("Not using %s because it's disabled until %s due to a previous error ", indexer.getName(), Instant.ofEpochMilli(indexer.getConfig().getDisabledUntil())); return handleIndexerNotSelected(indexer, message, "Disabled temporarily because of previous errors"); } if (indexer.getConfig().getState() == IndexerConfig.State.DISABLED_SYSTEM) { String message = String.format("Not using %s because it's disabled due to a previous unrecoverable error", indexer.getName()); return handleIndexerNotSelected(indexer, message, "Disabled permanently because of previous unrecoverable error"); } return true; } IndexerForSearchSelection pickIndexers(SearchRequest searchRequest); static final Pattern SCHEDULER_PATTERN; }### Answer: @Test public void shouldCheckIfDisabledBySystem() { when(searchingConfig.isIgnoreTemporarilyDisabled()).thenReturn(false); indexerConfigMock.setState(IndexerConfig.State.ENABLED); indexerConfigMock.setDisabledUntil(null); assertTrue(testee.checkIndexerStatus(indexer)); indexerConfigMock.setState(IndexerConfig.State.DISABLED_SYSTEM_TEMPORARY); indexerConfigMock.setDisabledUntil(Instant.now().plus(1, ChronoUnit.DAYS).toEpochMilli()); assertFalse(testee.checkIndexerStatus(indexer)); indexerConfigMock.setState(IndexerConfig.State.DISABLED_SYSTEM); assertFalse(testee.checkIndexerStatus(indexer)); }
### Question: ConfigMigration { protected static List<ConfigMigrationStep> getMigrationSteps() { ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false); provider.addIncludeFilter(new AssignableTypeFilter(ConfigMigrationStep.class)); Set<BeanDefinition> candidates = provider.findCandidateComponents(ConfigMigrationStep.class.getPackage().getName()); List<ConfigMigrationStep> steps = new ArrayList<>(); for (BeanDefinition beanDefinition : candidates) { try { ConfigMigrationStep instance = (ConfigMigrationStep) Class.forName(beanDefinition.getBeanClassName()).getConstructor().newInstance(); steps.add(instance); } catch (Exception e) { logger.error("Unable to instantiate migration step from class " + beanDefinition.getBeanClassName(), e); } } Collections.sort(steps); return steps; } ConfigMigration(); Map<String, Object> migrate(Map<String, Object> map); }### Answer: @Test public void shouldFindMigrationStepsForAllPossibleConfigVersions() { Integer currentConfigVersion = new MainConfig().getConfigVersion(); List<ConfigMigrationStep> steps = ConfigMigration.getMigrationSteps(); for (int i = 3; i < currentConfigVersion; i++) { int finalI = i; assertThat(steps.stream().anyMatch(x -> x.forVersion() == finalI)).isTrue(); } }
### Question: ConfigMigrationStep005to006 implements ConfigMigrationStep { @Override public Map<String, Object> migrate(Map<String, Object> toMigrate) { Map<String, Object> categoriesConfig = getFromMap(toMigrate, "categoriesConfig"); List<Map<String, Object>> categories = getListFromMap(categoriesConfig, "categories"); for (Map<String, Object> category : categories) { List<Integer> existingNumbers = (List<Integer>) category.get("newznabCategories"); category.put("newznabCategories", existingNumbers.stream().map(Object::toString).collect(Collectors.toList())); } return toMigrate; } @Override int forVersion(); @Override Map<String, Object> migrate(Map<String, Object> toMigrate); }### Answer: @Test public void migrate() throws Exception { String yaml = Resources.toString(ConfigMigrationStep005to006Test.class.getResource("migrate5to6.yaml"), Charset.defaultCharset()); Map<String, Object> map = Jackson.YAML_MAPPER.readValue(yaml, ConfigReaderWriter.MAP_TYPE_REFERENCE); Map<String, Object> migrated = testee.migrate(map); String newYaml = Jackson.YAML_MAPPER.writeValueAsString(migrated); BaseConfig baseConfig = Jackson.YAML_MAPPER.readValue(newYaml, BaseConfig.class); assertThat(baseConfig.getCategoriesConfig().getCategories().get(0).getNewznabCategories().get(0).get(0)).isEqualTo(1000); assertThat(baseConfig.getCategoriesConfig().getCategories().get(1).getNewznabCategories().get(0).get(0)).isEqualTo(3000); assertThat(baseConfig.getCategoriesConfig().getCategories().get(1).getNewznabCategories().get(1).get(0)).isEqualTo(3030); }
### Question: NewsProvider { public List<NewsEntry> getNews() throws IOException { if (Instant.now().minus(2, ChronoUnit.HOURS).isAfter(lastCheckedForNews)) { newsEntries = webAccess.callUrl(newsUrl, new TypeReference<List<NewsEntry>>() { }); newsEntries.sort(Comparator.comparing(NewsEntry::getShowForVersion).reversed()); lastCheckedForNews = Instant.now(); } return newsEntries; } List<NewsEntry> getNews(); void saveShownForCurrentVersion(); List<NewsEntry> getNewsForCurrentVersionAndAfter(); }### Answer: @Test public void getNews() throws Exception { List<NewsEntry> entries = testee.getNews(); assertThat(entries.size(), is(3)); assertThat(entries.get(0).getNewsAsMarkdown(), is("news3.0.0")); assertThat(entries.get(0).getShowForVersion().major, is(3)); }
### Question: IndexerForSearchSelector { protected boolean checkDisabledForCategory(Indexer indexer) { if (searchRequest.getCategory().getSubtype().equals(Subtype.ALL)) { return true; } boolean indexerDisabledForThisCategory = !indexer.getConfig().getEnabledCategories().isEmpty() && !indexer.getConfig().getEnabledCategories().contains(searchRequest.getCategory().getName()); if (indexerDisabledForThisCategory) { String message = String.format("Not using %s because it's disabled for category %s", indexer.getName(), searchRequest.getCategory().getName()); return handleIndexerNotSelected(indexer, message, "Disabled for category"); } return true; } IndexerForSearchSelection pickIndexers(SearchRequest searchRequest); static final Pattern SCHEDULER_PATTERN; }### Answer: @Test public void shouldCheckForCategory() { when(searchRequest.getCategory()).thenReturn(category); indexerConfigMock.setEnabledCategories(Collections.emptyList()); assertTrue(testee.checkDisabledForCategory(indexer)); indexerConfigMock.setEnabledCategories(Arrays.asList("anotherCategory")); assertFalse(testee.checkDisabledForCategory(indexer)); indexerConfigMock.setEnabledCategories(Arrays.asList(("category"))); assertTrue(testee.checkDisabledForCategory(indexer)); }
### Question: Binsearch extends Indexer<String> { @Override protected UriComponentsBuilder buildSearchUrl(SearchRequest searchRequest, Integer offset, Integer limit) throws IndexerSearchAbortedException { String query = super.generateQueryIfApplicable(searchRequest, ""); query = addRequiredWordsToQuery(searchRequest, query); if (Strings.isNullOrEmpty(query)) { throw new IndexerSearchAbortedException("Binsearch cannot search without a query"); } query = cleanupQuery(query); return UriComponentsBuilder.fromHttpUrl("https: } @Override NfoResult getNfo(String guid); }### Answer: @Test public void shouldBuildSimpleQuery() throws IndexerSearchAbortedException { SearchRequest searchRequest = new SearchRequest(SearchSource.INTERNAL, SearchType.SEARCH, 0, 100); searchRequest.setQuery("query"); UriComponentsBuilder builder = testee.buildSearchUrl(searchRequest, 0, 100); assertThat(builder.toUriString(), is("https: } @Test public void shouldAddRequiredWords() throws IndexerSearchAbortedException { SearchRequest searchRequest = new SearchRequest(SearchSource.INTERNAL, SearchType.SEARCH, 0, 100); searchRequest.getInternalData().setRequiredWords(Arrays.asList("a", "b")); searchRequest.setQuery("query"); UriComponentsBuilder builder = testee.buildSearchUrl(searchRequest, 0, 100); assertThat(builder.build().toString(), is("https: } @Test(expected = IndexerSearchAbortedException.class) public void shouldAbortIfSearchNotPossible() throws IndexerSearchAbortedException { SearchRequest searchRequest = new SearchRequest(SearchSource.INTERNAL, SearchType.SEARCH, 0, 100); testee.buildSearchUrl(searchRequest, 0, 100); }
### Question: IndexerForSearchSelector { protected boolean checkLoadLimiting(Indexer indexer) { boolean preventedByLoadLimiting = indexer.getConfig().getLoadLimitOnRandom().isPresent() && random.nextInt(indexer.getConfig().getLoadLimitOnRandom().get()) + 1 != 1; if (preventedByLoadLimiting) { boolean loadLimitIgnored = configProvider.getBaseConfig().getSearching().isIgnoreLoadLimitingForInternalSearches() && searchRequest.getSource() == SearchSource.INTERNAL; if (loadLimitIgnored) { logger.debug("Ignoring load limiting for internal search"); return true; } String message = String.format("Not using %s because load limiting prevented it. Chances of it being picked: 1/%d", indexer.getName(), indexer.getConfig().getLoadLimitOnRandom().get()); return handleIndexerNotSelected(indexer, message, "Load limiting"); } return true; } IndexerForSearchSelection pickIndexers(SearchRequest searchRequest); static final Pattern SCHEDULER_PATTERN; }### Answer: @Test public void shouldCheckForLoadLimiting() { indexerConfigMock.setLoadLimitOnRandom(null); assertTrue(testee.checkLoadLimiting(indexer)); indexerConfigMock.setLoadLimitOnRandom(1); for (int i = 0; i < 50; i++) { assertTrue(testee.checkLoadLimiting(indexer)); } indexerConfigMock.setLoadLimitOnRandom(2); int countNotPicked = 0; for (int i = 0; i < 500; i++) { countNotPicked += testee.checkLoadLimiting(indexer) ? 0 : 1; } assertTrue(countNotPicked > 0); }
### Question: Binsearch extends Indexer<String> { @Override protected String getAndStoreResultToDatabase(URI uri, IndexerApiAccessType apiAccessType) throws IndexerAccessException { return Failsafe.with(retry503policy) .onFailedAttempt(throwable -> logger.warn("Encountered 503 error. Will retry")) .get(() -> getAndStoreResultToDatabase(uri, String.class, apiAccessType)); } @Override NfoResult getNfo(String guid); }### Answer: @Test(expected = FailsafeException.class) public void shouldRetryOn503() throws Exception { testee = spy(testee); doThrow(new IndexerAccessException("503")).when(testee).getAndStoreResultToDatabase(uriCaptor.capture(), any(), any()); testee.getAndStoreResultToDatabase(null, IndexerApiAccessType.NFO); }
### Question: Indexer { protected void handleSuccess(IndexerApiAccessType accessType, Long responseTime) { if (getConfig().getDisabledLevel() > 0) { debug("Indexer was successfully called after {} failed attempts in a row", getConfig().getDisabledLevel()); } getConfig().setState(IndexerConfig.State.ENABLED); getConfig().setLastError(null); getConfig().setDisabledUntil(null); getConfig().setDisabledLevel(0); configProvider.getBaseConfig().save(false); saveApiAccess(accessType, responseTime, IndexerAccessResult.SUCCESSFUL, true); } void initialize(IndexerConfig config, IndexerEntity indexer); @EventListener void handleNewConfig(ConfigChangedEvent configChangedEvent); IndexerSearchResult search(SearchRequest searchRequest, int offset, Integer limit); abstract NfoResult getNfo(String guid); String getName(); IndexerConfig getConfig(); IndexerEntity getIndexerEntity(); String cleanUpTitle(String title); Optional<Instant> tryParseDate(String dateString); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); }### Answer: @Test public void handleSuccess() throws Exception { indexerConfig.setState(IndexerConfig.State.DISABLED_SYSTEM_TEMPORARY); indexerConfig.setDisabledLevel(1); indexerConfig.setDisabledUntil(Instant.now().toEpochMilli()); testee.handleSuccess(IndexerApiAccessType.SEARCH, 0L); assertThat(indexerConfig.getState(), is(IndexerConfig.State.ENABLED)); assertThat(indexerConfig.getDisabledLevel(), is(0)); assertThat(indexerConfig.getDisabledUntil(), is(nullValue())); }
### Question: Torznab extends Newznab { @Override protected UriComponentsBuilder buildSearchUrl(SearchRequest searchRequest, Integer offset, Integer limit) throws IndexerSearchAbortedException { return super.buildSearchUrl(searchRequest, null, null); } }### Answer: @Test public void shouldNotAddExcludedWordsToQuery() throws Exception { SearchRequest searchRequest = new SearchRequest(SearchSource.INTERNAL, SearchType.SEARCH, 0, 100); searchRequest.getInternalData().setForbiddenWords(Arrays.asList("notthis", "alsonotthis")); searchRequest.setQuery("query"); UriComponentsBuilder builder = testee.buildSearchUrl(searchRequest, 0, 100); assertThat(builder.toUriString(), not(containsString("notthis"))); }
### Question: IndexerForSearchSelector { protected boolean checkSearchSource(Indexer indexer) { boolean wrongSearchSource = !indexer.getConfig().getEnabledForSearchSource().meets(searchRequest); if (wrongSearchSource) { String message = String.format("Not using %s because the search source is %s but the indexer is only enabled for %s searches", indexer.getName(), searchRequest.getSource(), indexer.getConfig().getEnabledForSearchSource()); return handleIndexerNotSelected(indexer, message, "Not enabled for this search context"); } return true; } IndexerForSearchSelection pickIndexers(SearchRequest searchRequest); static final Pattern SCHEDULER_PATTERN; }### Answer: @Test public void shouldCheckContext() { when(searchModuleProviderMock.getIndexers()).thenReturn(Arrays.asList(indexer)); when(searchRequest.getSource()).thenReturn(SearchSource.INTERNAL); indexerConfigMock.setEnabledForSearchSource(SearchSourceRestriction.API); assertFalse(testee.checkSearchSource(indexer)); when(searchRequest.getSource()).thenReturn(SearchSource.API); assertTrue(testee.checkSearchSource(indexer)); }
### Question: Anizb extends Indexer<NewznabXmlRoot> { @Override protected UriComponentsBuilder buildSearchUrl(SearchRequest searchRequest, Integer offset, Integer limit) throws IndexerSearchAbortedException { String query = super.generateQueryIfApplicable(searchRequest, ""); query = addRequiredWordsToQuery(searchRequest, query); if (Strings.isNullOrEmpty(query)) { throw new IndexerSearchAbortedException("Anizb cannot search without a query"); } query = cleanupQuery(query); return UriComponentsBuilder.fromHttpUrl("https: } @Override NfoResult getNfo(String guid); }### Answer: @Test public void shouldBuildSimpleQuery() throws IndexerSearchAbortedException { SearchRequest searchRequest = new SearchRequest(SearchSource.INTERNAL, SearchType.SEARCH, 0, 100); searchRequest.setQuery("query"); UriComponentsBuilder builder = testee.buildSearchUrl(searchRequest, 0, 100); assertThat(builder.toUriString(), is("https: } @Test public void shouldAddRequiredWords() throws IndexerSearchAbortedException { SearchRequest searchRequest = new SearchRequest(SearchSource.INTERNAL, SearchType.SEARCH, 0, 100); searchRequest.getInternalData().setRequiredWords(Arrays.asList("a", "b")); searchRequest.setQuery("query"); UriComponentsBuilder builder = testee.buildSearchUrl(searchRequest, 0, 100); assertThat(builder.toUriString(), is("https: } @Test(expected = IndexerSearchAbortedException.class) public void shouldAbortIfSearchNotPossible() throws IndexerSearchAbortedException { SearchRequest searchRequest = new SearchRequest(SearchSource.INTERNAL, SearchType.SEARCH, 0, 100); testee.buildSearchUrl(searchRequest, 0, 100); }
### Question: NzbsOrg extends Newznab { protected String addRequiredWords(SearchRequest searchRequest, String query) { List<String> allRequiredWords = new ArrayList<>(searchRequest.getInternalData().getRequiredWords()); allRequiredWords.addAll(configProvider.getBaseConfig().getSearching().getRequiredWords()); allRequiredWords.addAll(searchRequest.getCategory().getRequiredWords()); List<String> allPossibleRequiredWords = allRequiredWords.stream().filter(x -> !(x.contains(" ") \|\| x.contains("-") \|\| x.contains("."))).collect(Collectors.toList()); if (allRequiredWords.size() > allPossibleRequiredWords.size()) { logger.debug("Not using some forbidden words in query because characters forbidden by newznab are contained"); } StringBuilder queryBuilder = new StringBuilder(query); for (String word : allPossibleRequiredWords) { if ((queryBuilder + word).length() < 255) { queryBuilder.append(" ").append(queryBuilder); } } query = queryBuilder.toString(); return query; } }### Answer: @Test public void shouldLimitQueryLengthWhenAddingRequiredWords() throws Exception { SearchRequest request = new SearchRequest(SearchSource.INTERNAL, SearchType.SEARCH, 0, 100); request.getInternalData().setRequiredWords(Arrays.asList("characters50sssssssssssssssssssssssssssssssssssss1", "characters50sssssssssssssssssssssssssssssssssssss2", "characters50sssssssssssssssssssssssssssssssssssss3", "characters50sssssssssssssssssssssssssssssssssssss4", "characters40ssssssssssssssssssssssssssss", "aaaaa", "bbbbb")); String query = testee.addRequiredWords(request, ""); assertThat(query.length()).isLessThan(255); }
### Question: NzbsOrg extends Newznab { @Override protected String cleanupQuery(String query) { query = super.cleanupQuery(query); if (query.length() > 255) { logger.warn("Truncating query because its length is {} but only 255 characters are supported", query.length()); StringBuilder shorterQuery = new StringBuilder(); for (String s : query.split(" ")) { if ((shorterQuery + s).length() < 255) { shorterQuery.append(" ").append(s); } else { break; } } query = shorterQuery.toString(); } return query; } }### Answer: @Test public void shouldTruncateLongQuery() { StringBuilder longQuery = new StringBuilder(); for (int i = 0; i < 56; i++) { longQuery.append(" " + "characters15sss"); }assertThat(longQuery.length()).isGreaterThan(255); String query = testee.cleanupQuery(longQuery.toString()); assertThat(query.length()).isLessThan(255); }
### Question: IndexerForSearchSelector { protected boolean checkSearchId(Indexer indexer) { boolean needToSearchById = !searchRequest.getIdentifiers().isEmpty() && !searchRequest.getQuery().isPresent(); if (needToSearchById) { boolean canUseAnyProvidedId = !Collections.disjoint(searchRequest.getIdentifiers().keySet(), indexer.getConfig().getSupportedSearchIds()); boolean cannotSearchProvidedOrConvertableId = !canUseAnyProvidedId && !infoProvider.canConvertAny(searchRequest.getIdentifiers().keySet(), Sets.newHashSet(indexer.getConfig().getSupportedSearchIds())); boolean queryGenerationEnabled = configProvider.getBaseConfig().getSearching().getGenerateQueries().meets(searchRequest); if (cannotSearchProvidedOrConvertableId && !queryGenerationEnabled) { String message = String.format("Not using %s because the search did not provide any ID that the indexer can handle and query generation is disabled", indexer.getName()); return handleIndexerNotSelected(indexer, message, "No usable ID"); } } return true; } IndexerForSearchSelection pickIndexers(SearchRequest searchRequest); static final Pattern SCHEDULER_PATTERN; }### Answer: @Test public void shouldCheckIdConversion() { Set<MediaIdType> supported = Sets.newSet(MediaIdType.TVMAZE, MediaIdType.TVDB); Set<MediaIdType> provided = Sets.newSet(MediaIdType.TVMAZE); when(searchRequest.getQuery()).thenReturn(Optional.empty()); when(infoProviderMock.canConvertAny(provided, supported)).thenReturn(true); assertTrue(testee.checkSearchId(indexer)); when(searchRequest.getQuery()).thenReturn(Optional.of("a query")); when(infoProviderMock.canConvertAny(provided, supported)).thenReturn(false); assertTrue(testee.checkSearchId(indexer)); provided = new HashSet<>(); when(searchRequest.getQuery()).thenReturn(Optional.empty()); verify(infoProviderMock, never()).canConvertAny(provided, supported); assertTrue(testee.checkSearchId(indexer)); }
### Question: CurrentTenantHolder { public static String pop() { return getCurrentStack().pop(); } static void push(String tenantId); static String pop(); static String getCurrentTenant(); }### Answer: @Test(expected = EmptyStackException.class) public void testEmptyHolderPop() { CurrentTenantHolder.pop(); }
### Question: CurrentTenantHolder { public static String getCurrentTenant() { return getCurrentStack().peek(); } static void push(String tenantId); static String pop(); static String getCurrentTenant(); }### Answer: @Test(expected = EmptyStackException.class) public void testEmptyHolderPeek() { CurrentTenantHolder.getCurrentTenant(); }
### Question: DeltaJournal implements InitializingBean { public void journal(Collection<String> ids, String collection, boolean isDelete) { if ( collection.equals("applicationAuthorization") ) { return; } if (deltasEnabled && !TenantContext.isSystemCall()) { if (subdocCollectionsToCollapse.containsKey(collection)) { journalCollapsedSubDocs(ids, collection); } long now = new Date().getTime(); Update update = new Update(); update.set("t", now); update.set("c", collection); if (isDelete) { update.set("d", now); } else { update.set("u", now); } for (String id : ids) { List<byte[]> idbytes = getByteId(id); if(idbytes.size() > 1) { update.set("i", idbytes.subList(1, idbytes.size())); } template.upsert(Query.query(where("_id").is(idbytes.get(0))), update, DELTA_COLLECTION); } } } @Override void afterPropertiesSet(); void journal(Collection<String> ids, String collection, boolean isDelete); static List<byte[]> getByteId(String id); static String getEntityId(Map<String, Object> deltaRecord); void journal(String id, String collection, boolean isDelete); void journalCollapsedSubDocs(Collection<String> ids, String collection); void journalPurge(long timeOfPurge); Iterator<Map<String, Object>> findDeltaRecordBetween(final long start, final long end); void removeDeltaJournals(String tenant, long cleanUptoTime); static final String DELTA_COLLECTION; static final String PURGE; }### Answer: @Test public void testIgnoredOnSystemCall() { TenantContext.setIsSystemCall(true); deltaJournal.journal("test", "userSession", false); verify(template, never()).upsert(any(Query.class), any(Update.class), anyString()); TenantContext.setIsSystemCall(false); }
### Question: DeltaJournal implements InitializingBean { public void journalPurge(long timeOfPurge) { String id = uuidGeneratorStrategy.generateId(); Update update = new Update(); update.set("t", timeOfPurge); update.set("c", PURGE); TenantContext.setIsSystemCall(false); template.upsert(Query.query(where("_id").is(id)), update, DELTA_COLLECTION); } @Override void afterPropertiesSet(); void journal(Collection<String> ids, String collection, boolean isDelete); static List<byte[]> getByteId(String id); static String getEntityId(Map<String, Object> deltaRecord); void journal(String id, String collection, boolean isDelete); void journalCollapsedSubDocs(Collection<String> ids, String collection); void journalPurge(long timeOfPurge); Iterator<Map<String, Object>> findDeltaRecordBetween(final long start, final long end); void removeDeltaJournals(String tenant, long cleanUptoTime); static final String DELTA_COLLECTION; static final String PURGE; }### Answer: @Test public void testJournalPurge() { final long time = new Date().getTime(); deltaJournal.journalPurge(time); BaseMatcher<Update> updateMatcher = new BaseMatcher<Update>() { @Override public boolean matches(Object arg0) { @SuppressWarnings("unchecked") Map<String, Object> o = (Map<String, Object>) ((Update) arg0).getUpdateObject().get("$set"); if (o.get("c").equals("purge") && o.get("t").equals(time)) { return true; } return false; } @Override public void describeTo(Description arg0) { arg0.appendText("Update with 'c' set to 'purge' and 't' set to time of purge"); } }; verify(template, Mockito.times(1)).upsert(Mockito.any(Query.class), argThat(updateMatcher), Mockito.eq("deltas")); }
### Question: StudentAssessmentConverter extends GenericSuperdocConverter implements SuperdocConverter { @Override public void bodyFieldToSubdoc(Entity entity) { bodyFieldToSubdoc(entity, null); } @Override Entity subdocToBodyField(Entity entity); @Override void bodyFieldToSubdoc(Entity entity); @Override void bodyFieldToSubdoc(Entity entity, SuperdocConverter.Option option); @Override Iterable<Entity> subdocToBodyField(Iterable<Entity> entities); @Override void bodyFieldToSubdoc(Iterable<Entity> entities); @Override void bodyFieldToSubdoc(Iterable<Entity> entities, SuperdocConverter.Option option); }### Answer: @Test public void testBodyFieldToSubdoc() { List<Entity> entities = Arrays.asList(createDownConvertEntity()); assertNotNull("studentAssessment body should have studentAssessmentItem", entities.get(0).getBody().get("studentAssessmentItems")); assertNull("studentAssessmentItem should not be outside the studentAssessment body", entities.get(0) .getEmbeddedData().get("studentAssessmentItem")); saConverter.bodyFieldToSubdoc(entities); assertNull("studentAssessment body should not have studentAssessmentItem", entities.get(0).getBody().get("studentAssessmentItems")); assertNotNull("studentAssessmentItem should be moved outside body", entities.get(0).getEmbeddedData().get("studentAssessmentItem")); } @SuppressWarnings("unchecked") @Test public void testSubdocDid() { List<Entity> entities = Arrays.asList(createDownConvertEntity()); assertNull( "studentAssessmentItem should not have id before transformation", ((List<Map<String, Object>>) (entities.get(0).getBody().get("studentAssessmentItems"))).get(0).get( "_id")); saConverter.bodyFieldToSubdoc(entities); assertFalse("subdoc id should be generated", entities.get(0).getEmbeddedData().get("studentAssessmentItem") .get(0).getEntityId().isEmpty()); }
### Question: ContainerDocumentAccessor { public boolean isContainerDocument(final String entity) { return containerDocumentHolder.isContainerDocument(entity); } ContainerDocumentAccessor(final UUIDGeneratorStrategy strategy, final INaturalKeyExtractor extractor, final MongoTemplate mongoTemplate, final SchemaRepository schemaRepo); boolean isContainerDocument(final String entity); boolean isContainerSubdoc(final String entity); boolean insert(final List<Entity> entityList); String insert(final Entity entity); boolean update(final String type, final String id, Map<String, Object> newValues, String collectionName); String update(final Entity entity); Entity findById(String collectionName, String id); List<Entity> findAll(String collectionName, Query query); boolean delete(final Entity entity); @SuppressWarnings("unchecked") boolean deleteContainerNonSubDocs(final Entity containerDoc); long count(String collectionName, Query query); boolean exists(String collectionName, String id); String getEmbeddedDocType(final String containerDocType); }### Answer: @Test public void testIsContainerDocument() { when(mockHolder.isContainerDocument(ATTENDANCE)).thenReturn(true); boolean actual = testAccessor.isContainerDocument(ATTENDANCE); assertEquals(true, actual); }
### Question: ContainerDocumentAccessor { public boolean isContainerSubdoc(final String entity) { boolean isContainerSubdoc = false; if (containerDocumentHolder.isContainerDocument(entity)) { isContainerSubdoc = containerDocumentHolder.getContainerDocument(entity).isContainerSubdoc(); } return isContainerSubdoc; } ContainerDocumentAccessor(final UUIDGeneratorStrategy strategy, final INaturalKeyExtractor extractor, final MongoTemplate mongoTemplate, final SchemaRepository schemaRepo); boolean isContainerDocument(final String entity); boolean isContainerSubdoc(final String entity); boolean insert(final List<Entity> entityList); String insert(final Entity entity); boolean update(final String type, final String id, Map<String, Object> newValues, String collectionName); String update(final Entity entity); Entity findById(String collectionName, String id); List<Entity> findAll(String collectionName, Query query); boolean delete(final Entity entity); @SuppressWarnings("unchecked") boolean deleteContainerNonSubDocs(final Entity containerDoc); long count(String collectionName, Query query); boolean exists(String collectionName, String id); String getEmbeddedDocType(final String containerDocType); }### Answer: @Test public void isContainerSubDoc() { final ContainerDocument cDoc2 = createContainerDocGrade(); when(mockHolder.isContainerDocument(ATTENDANCE)).thenReturn(true); when(mockHolder.isContainerDocument(GRADE)).thenReturn(true); when(mockHolder.getContainerDocument(GRADE)).thenReturn(cDoc2); assertFalse(testAccessor.isContainerSubdoc(ATTENDANCE)); assertTrue(testAccessor.isContainerSubdoc(GRADE)); }
### Question: FileEntryWorkNote extends WorkNote implements Serializable { public IngestionFileEntry getFileEntry() { return fileEntry; } FileEntryWorkNote(String batchJobId, IngestionFileEntry fileEntry, boolean hasErrors); IngestionFileEntry getFileEntry(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); }### Answer: @Test public void testCreateSimpleWorkNote() { FileEntryWorkNote workNote = new FileEntryWorkNote("batchJobId", null, false); Assert.assertEquals("batchJobId", workNote.getBatchJobId()); Assert.assertEquals(null, workNote.getFileEntry()); }
### Question: MongoEntityTemplate extends MongoTemplate { public <T> Iterator<T> findEach(final Query query, final Class<T> entityClass, String collectionName) { MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(entityClass); DBCollection collection = getDb().getCollection(collectionName); prepareCollection(collection); DBObject dbQuery = mapper.getMappedObject(query.getQueryObject(), entity); final DBCursor cursor; if (query.getFieldsObject() == null) { cursor = collection.find(dbQuery); } else { cursor = collection.find(dbQuery, query.getFieldsObject()); } return new Iterator<T>() { @Override public boolean hasNext() { return cursor.hasNext(); } @Override public T next() { return getConverter().read(entityClass, cursor.next()); } @Override public void remove() { cursor.remove(); } }; } MongoEntityTemplate(MongoDbFactory mongoDbFactory, MongoConverter mongoConverter); Iterator<T> findEach(final Query query, final Class<T> entityClass, String collectionName); }### Answer: @Test public void testReadPreference() { template.setReadPreference(ReadPreference.secondary()); Query query = new Query(); template.findEach(query, Entity.class, "student"); Assert.assertEquals(ReadPreference.secondary(), template.getCollection("student").getReadPreference()); }
### Question: AesCipher implements org.slc.sli.dal.encrypt.Cipher { @Override public String encrypt(Object data) { if (data instanceof String) { return "ESTRING:" + encryptFromBytes(StringUtils.getBytesUtf8((String) data)); } else { ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream(); DataOutputStream dos = new DataOutputStream(byteOutputStream); String type; try { if (data instanceof Boolean) { dos.writeBoolean((Boolean) data); type = "EBOOL:"; } else if (data instanceof Integer) { dos.writeInt((Integer) data); type = "EINT:"; } else if (data instanceof Long) { dos.writeLong((Long) data); type = "ELONG:"; } else if (data instanceof Double) { dos.writeDouble((Double) data); type = "EDOUBLE:"; } else { throw new RuntimeException("Unsupported type: " + data.getClass().getCanonicalName()); } dos.flush(); dos.close(); } catch (IOException e) { throw new RuntimeException(e); } byte[] bytes = byteOutputStream.toByteArray(); return type + encryptFromBytes(bytes); } } @Override String encrypt(Object data); @Override Object decrypt(String data); }### Answer: @Test(expected = RuntimeException.class) public void testUnhandled() { aes.encrypt(1.1F); }
### Question: AesCipher implements org.slc.sli.dal.encrypt.Cipher { @Override public Object decrypt(String data) { String[] splitData = org.apache.commons.lang3.StringUtils.split(data, ':'); if (splitData.length != 2) { return null; } else { if (splitData[0].equals("ESTRING")) { return StringUtils.newStringUtf8(decryptToBytes(splitData[1])); } else if (splitData[0].equals("EBOOL")) { return decryptBinary(splitData[1], Boolean.class); } else if (splitData[0].equals("EINT")) { return decryptBinary(splitData[1], Integer.class); } else if (splitData[0].equals("ELONG")) { return decryptBinary(splitData[1], Long.class); } else if (splitData[0].equals("EDOUBLE")) { return decryptBinary(splitData[1], Double.class); } else { return null; } } } @Override String encrypt(Object data); @Override Object decrypt(String data); }### Answer: @Test() public void testUnencryptedString() { Object decrypted = aes.decrypt("Some text"); assertEquals(null, decrypted); Object d2 = aes.decrypt("SOME DATA WITH : IN IT"); assertEquals(null, d2); }
### Question: JsonConverter { public static String toJson(Object o) { return GSON.toJson(o); } static String toJson(Object o); static T fromJson(String json, Class<T> clazz); static T fromJson(Reader reader, Class<T> clazz); }### Answer: @Test public void test() { GenericEntity entity = new GenericEntity(); GenericEntity element = new GenericEntity(); element.put("tire", "Yokohama"); entity.put("car", element); assertEquals("{\"car\":{\"tire\":\"Yokohama\"}}", JsonConverter.toJson(entity)); }
### Question: Response extends WadlElement { public List<String> getStatusCodes() { return statusCodes; } Response(final List<String> statusCodes, final List<Documentation> doc, final List<Param> params, final List<Representation> representations); List<String> getStatusCodes(); List<Param> getParams(); List<Representation> getRepresentations(); @Override String toString(); }### Answer: @Test public void testGetStatusCodes() { assertEquals(STATUS_CODES, response.getStatusCodes()); }
### Question: TenantMongoDA implements TenantDA { @Override public void insertTenant(TenantRecord tenant) { if (entityRepository.findOne(TENANT_COLLECTION, new NeutralQuery(new NeutralCriteria(TENANT_ID, "=", tenant.getTenantId()))) == null) { entityRepository.create(TENANT_COLLECTION, getTenantBody(tenant)); } } @Override List<String> getLzPaths(); @Override String getTenantId(String lzPath); @Override void insertTenant(TenantRecord tenant); @Override @SuppressWarnings("unchecked") String getTenantEdOrg(String lzPath); Repository<Entity> getEntityRepository(); void setEntityRepository(Repository<Entity> entityRepository); @SuppressWarnings("unchecked") @Override Map<String, List<String>> getPreloadFiles(String ingestionServer); @Override boolean tenantDbIsReady(String tenantId); @Override void setTenantReadyFlag(String tenantId); @Override void unsetTenantReadyFlag(String tenantId); @Override boolean updateAndAquireOnboardingLock(String tenantId); @Override void removeInvalidTenant(String lzPath); @Override Map<String, List<String>> getPreloadFiles(); @Override List<String> getAllTenantDbs(); static final String TENANT_ID; static final String DB_NAME; static final String INGESTION_SERVER; static final String PATH; static final String LANDING_ZONE; static final String PRELOAD_DATA; static final String PRELOAD_STATUS; static final String PRELOAD_FILES; static final String TENANT_COLLECTION; static final String TENANT_TYPE; static final String EDUCATION_ORGANIZATION; static final String DESC; static final String ALL_STATUS_FIELDS; static final String STATUS_FIELD; }### Answer: @Test public void shouldInsertTenant() { TenantRecord tenantRecord = createTestTenantRecord(); tenantDA.insertTenant(tenantRecord); Mockito.verify(mockRepository).create(Mockito.eq("tenant"), Mockito.argThat(new IsCorrectBody(tenantRecord))); }
### Question: Response extends WadlElement { public List<Param> getParams() { return params; } Response(final List<String> statusCodes, final List<Documentation> doc, final List<Param> params, final List<Representation> representations); List<String> getStatusCodes(); List<Param> getParams(); List<Representation> getRepresentations(); @Override String toString(); }### Answer: @Test public void testGetParams() { assertEquals(PARAMS, response.getParams()); }
### Question: Response extends WadlElement { public List<Representation> getRepresentations() { return representations; } Response(final List<String> statusCodes, final List<Documentation> doc, final List<Param> params, final List<Representation> representations); List<String> getStatusCodes(); List<Param> getParams(); List<Representation> getRepresentations(); @Override String toString(); }### Answer: @Test public void testGetRepresentations() { assertEquals(REPRESENTATIONS, response.getRepresentations()); }
### Question: Response extends WadlElement { @Override public String toString() { final StringBuilder sb = new StringBuilder(); sb.append("{"); sb.append("statusCodes").append(" : ").append(statusCodes); sb.append(", "); sb.append("params").append(" : ").append(params); sb.append(", "); sb.append("representations").append(" : ").append(representations); sb.append(", "); sb.append("doc").append(" : ").append(getDocumentation()); sb.append("}"); return sb.toString(); } Response(final List<String> statusCodes, final List<Documentation> doc, final List<Param> params, final List<Representation> representations); List<String> getStatusCodes(); List<Param> getParams(); List<Representation> getRepresentations(); @Override String toString(); }### Answer: @Test public void testToString() { assertTrue(!"".equals(response.toString())); }
### Question: Request extends WadlElement { public List<Param> getParams() { return params; } Request(final List<Documentation> doc, final List<Param> params, final List<Representation> representations); List<Param> getParams(); List<Representation> getRepresentations(); @Override String toString(); }### Answer: @Test public void testGetParams() { assertEquals(PARAMS, request.getParams()); }
### Question: Request extends WadlElement { public List<Representation> getRepresentations() { return representations; } Request(final List<Documentation> doc, final List<Param> params, final List<Representation> representations); List<Param> getParams(); List<Representation> getRepresentations(); @Override String toString(); }### Answer: @Test public void testGetRepresentations() { assertEquals(REPRESENTATIONS, request.getRepresentations()); }

Subsets and Splits