Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
CompositeParameters extends AbstractParameterParser { @Nonnull public CompositeParameters add (final String sKey, final AbstractParameterParser aParam) { getParameterParsers ().put (sKey, aParam); return this; } CompositeParameters(final boolean bIgnoreMissingParsers); CompositeParameters(final boolean bIgnoreMissingParsers, @Nonnull final Map <String, ? extends AbstractParameterParser> aParameterParsers); @Nonnull CompositeParameters add(final String sKey, final AbstractParameterParser aParam); void setIgnoreMissingParsers(final boolean bIgnoreMissingParsers); boolean isIgnoreMissingParsers(); @Override void setParameter(final String sKey, final String sValue); @Override String getParameter(final String sKey); void setParameterParsers(@Nullable final ICommonsMap <String, AbstractParameterParser> aParameterParsers); }
@Test public void testBasic () throws AS2InvalidParameterException { final AS2Message aMsg = new AS2Message (); aMsg.headers ().addHeader ("message-id", "12345"); aMsg.partnership ().setSenderAS2ID ("s1"); aMsg.partnership ().setReceiverAS2ID ("r1"); final ZonedDateTime aTestDT = PDTFactory.getCurrentZonedDateTime (); final CompositeParameters aParams = new CompositeParameters (false).add ("date", new DateParameters (aTestDT)) .add ("msg", new MessageParameters (aMsg)); final String sNow = PDTFormatter.getForPattern ("uuuuMMddhhmmss").format (aTestDT); String sName = aParams.format ("$date.uuuuMMddhhmmss$"); assertEquals (sNow, sName); sName = aParams.format ("any$date.uuuuMMddhhmmss$else"); assertEquals ("any" + sNow + "else", sName); sName = aParams.format ("$date.uuuuMMddhhmmss$$date.uuuuMMddhhmmss$"); assertEquals (sNow + sNow, sName); assertEquals ("sender.as2_id, receiver.as2_id, headers.message-id", aParams.format ("sender.as2_id, receiver.as2_id, headers.message-id")); assertEquals ("s1, r1, 12345", aParams.format ("$msg.sender.as2_id$, $msg.receiver.as2_id$, $msg.headers.message-id$")); try { aParams.format ("$dummy$"); fail (); } catch (final AS2InvalidParameterException ex) {} assertEquals ("$s1", aParams.format ("$$$msg.sender.as2_id$")); assertEquals ("$$s1", aParams.format ("$$$$$msg.sender.as2_id$")); assertEquals ("s1$", aParams.format ("$msg.sender.as2_id$$$")); assertEquals ("s1$$", aParams.format ("$msg.sender.as2_id$$$$$")); assertEquals ("s1$r1", aParams.format ("$msg.sender.as2_id$$$$msg.receiver.as2_id$")); assertEquals ("s1$$r1", aParams.format ("$msg.sender.as2_id$$$$$$msg.receiver.as2_id$")); assertEquals ("$$s1$$r1$$", aParams.format ("$$$$$msg.sender.as2_id$$$$$$msg.receiver.as2_id$$$$$")); } @Test public void testIgnore () throws AS2InvalidParameterException { final AS2Message aMsg = new AS2Message (); aMsg.headers ().addHeader ("message-id", "12345"); aMsg.partnership ().setSenderAS2ID ("s1"); aMsg.partnership ().setReceiverAS2ID ("r1"); final CompositeParameters aParams = new CompositeParameters (true).add ("msg", new MessageParameters (aMsg)); assertEquals ("sender.as2_id, receiver.as2_id, headers.message-id", aParams.format ("sender.as2_id, receiver.as2_id, headers.message-id")); assertEquals ("s1, r1, 12345", aParams.format ("$msg.sender.as2_id$, $msg.receiver.as2_id$, $msg.headers.message-id$")); assertEquals ("", aParams.format ("$dummy$")); assertEquals ("any", aParams.format ("any$dummy$")); assertEquals ("any", aParams.format ("$dummy$any")); assertEquals ("foobar", aParams.format ("foo$dummy$bar")); }
MongoDBPartnershipFactory extends AbstractDynamicComponent implements IPartnershipFactory { @Override public EChange addPartnership (final Partnership aPartnership) throws AS2Exception { m_aPartnerships.insertOne (_toDocument (aPartnership)); return EChange.CHANGED; } MongoDBPartnershipFactory(final MongoCollection <Document> aPartnerships, final Logger aLogger); @Override EChange addPartnership(final Partnership aPartnership); @Override EChange removePartnership(final Partnership aPartnership); @Override void updatePartnership(final IMessage aMsg, final boolean bOverwrite); @Override void updatePartnership(final IMessageMDN aMdn, final boolean bOverwrite); @Override Partnership getPartnership(final Partnership aPartnership); @Override Partnership getPartnershipByName(final String sName); @Override ICommonsSet <String> getAllPartnershipNames(); @Override ICommonsList <Partnership> getAllPartnerships(); }
@Test public void testAddPartnership () throws AS2Exception { final Partnership partnership = new Partnership ("Test partnership"); assertTrue (mongoDBPartnershipFactory.addPartnership (partnership).isChanged ()); assertEquals (1, collection.countDocuments ()); assertNotNull (mongoDBPartnershipFactory.getPartnershipByName ("Test partnership")); }
DiscreteAnneal { public String getStatus() { final StringBuilder result = new StringBuilder(); result.append("k="); result.append(this.k); result.append(",kMax="); result.append(this.kMax); result.append(",t="); result.append(this.currentTemperature); result.append(",prob="); result.append(this.lastProbability); return result.toString(); } DiscreteAnneal(final int theKMax, final double theStartingTemperature, final double theEndingTemperature); double coolingSchedule(); void iteration(); abstract void backupState(); abstract void restoreState(); abstract void foundNewBest(); abstract void moveToNeighbor(); abstract double evaluate(); boolean done(); double getBestScore(); double calcProbability(final double ecurrent, final double enew, final double t); int getK(); int getCycles(); void setCycles(final int cycles); String getStatus(); }
@Test public void testStatus() { final DiscreteAnnealSubclass anneal = new DiscreteAnnealSubclass(1000, 4000, 1); assertEquals("k=0,kMax=1000,t=0.0,prob=0.0", anneal.getStatus()); }
KMeans { public void initForgy(final List<BasicData> theObservations) { final int dimensions = findDimensions(theObservations); this.clusters.clear(); final Set<Integer> usedObservations = new HashSet<Integer>(); for (int i = 0; i < this.k; i++) { final Cluster cluster = new Cluster(dimensions); this.clusters.add(cluster); int observationIndex = -1; while (observationIndex == -1) { observationIndex = this.randomGeneration.nextInt(theObservations.size()); if (usedObservations.contains(observationIndex)) { observationIndex = -1; } } final double[] observation = theObservations.get(observationIndex).getInput(); System.arraycopy(observation, 0, cluster.getCenter(), 0, dimensions); usedObservations.add(observationIndex); } for (final BasicData observation : theObservations) { final Cluster cluster = findNearestCluster(observation.getInput()); cluster.getObservations().add(observation); } updateStep(); } KMeans(final int theK); void initRandom(final List<BasicData> theObservations); void initForgy(final List<BasicData> theObservations); Cluster findNearestCluster(final double[] observation); boolean iteration(); int iteration(final int maxIterations); GenerateRandom getRandomGeneration(); void setRandomGeneration(final GenerateRandom randomGeneration); CalculateDistance getDistanceMetric(); void setDistanceMetric(final CalculateDistance distanceMetric); int getK(); List<Cluster> getClusters(); }
@Test(expected = AIFHError.class) public void testNoObservations() { final List<BasicData> list = new ArrayList<BasicData>(); final KMeans kmeans = new KMeans(3); kmeans.initForgy(list); } @Test(expected = AIFHError.class) public void testNoDimension() { final List<BasicData> list = new ArrayList<BasicData>(); list.add(new BasicData(0)); final KMeans kmeans = new KMeans(3); kmeans.initForgy(list); }
BasicData { public String toString() { final StringBuilder result = new StringBuilder(); result.append("[BasicData: input:"); result.append(Arrays.toString(this.input)); result.append(", ideal:"); result.append(Arrays.toString(this.ideal)); result.append(", label:"); result.append(this.label); result.append("]"); return result.toString(); } BasicData(final int theInputDimensions); BasicData(final int theInputDimensions, final int theIdealDimensions); BasicData(final int theInputDimensions, final int theIdealDimensions, final String theLabel); BasicData(final double[] theInputData, final double[] theIdealData, final String theLabel); BasicData(final double[] theInputData, final String theLabel); BasicData(final double[] theInputData); double[] getInput(); double[] getIdeal(); String getLabel(); void setLabel(final String label); String toString(); static List<BasicData> convertArrays(final double[][] inputData, final double[][] idealData); }
@Test public void testToString() { final BasicData data = new BasicData(2); assertEquals("[BasicData: input:[0.0, 0.0], ideal:[], label:null]", data.toString()); }
VectorUtil { public static int maxIndex(final double[] a) { int result = -1; double max = Double.NEGATIVE_INFINITY; for (int i = 0; i < a.length; i++) { if (a[i] > max) { max = a[i]; result = i; } } return result; } private VectorUtil(); static int maxIndex(final double[] a); }
@Test public void testMaxIndex() { final double[] a = {2, 4, 10, 8}; assertEquals(2, VectorUtil.maxIndex(a), AIFH.DEFAULT_PRECISION); }
LogLinkFunction implements Fn { @Override public double evaluate(final double[] x) { if (x.length > 1) { throw new AIFHError("The logistic link function can only accept one parameter."); } return Math.log(x[0]); } @Override double evaluate(final double[] x); }
@Test public void testEvaluate() { final LogLinkFunction fn = new LogLinkFunction(); final double[] x = {2}; final double y = fn.evaluate(x); assertEquals(0.6931471805599453, y, AIFH.DEFAULT_PRECISION); } @Test(expected = AIFHError.class) public void testException() { final LogLinkFunction fn = new LogLinkFunction(); final double[] x = {1, 2}; fn.evaluate(x); }
IdentityLinkFunction implements Fn { @Override public double evaluate(final double[] x) { if (x.length > 1) { throw new AIFHError("The linear link function can only accept one parameter."); } return x[0]; } @Override double evaluate(final double[] x); }
@Test public void testEvaluate() { final IdentityLinkFunction fn = new IdentityLinkFunction(); final double[] x = {2}; final double y = fn.evaluate(x); assertEquals(2, y, AIFH.DEFAULT_PRECISION); } @Test(expected = AIFHError.class) public void testException() { final IdentityLinkFunction fn = new IdentityLinkFunction(); final double[] x = {1, 2}; fn.evaluate(x); }
InverseLinkFunction implements Fn { @Override public double evaluate(final double[] x) { if (x.length > 1) { throw new AIFHError("The inverse link function can only accept one parameter."); } return -Math.pow(x[0], -1); } @Override double evaluate(final double[] x); }
@Test public void testEvaluate() { final InverseLinkFunction fn = new InverseLinkFunction(); final double[] x = {2}; final double y = fn.evaluate(x); assertEquals(-0.5, y, AIFH.DEFAULT_PRECISION); } @Test(expected = AIFHError.class) public void testException() { final InverseLinkFunction fn = new InverseLinkFunction(); final double[] x = {1, 2}; fn.evaluate(x); }
DiscreteAnneal { public double coolingSchedule() { final double ex = (double) k / (double) kMax; return this.startingTemperature * Math.pow(this.endingTemperature / this.startingTemperature, ex); } DiscreteAnneal(final int theKMax, final double theStartingTemperature, final double theEndingTemperature); double coolingSchedule(); void iteration(); abstract void backupState(); abstract void restoreState(); abstract void foundNewBest(); abstract void moveToNeighbor(); abstract double evaluate(); boolean done(); double getBestScore(); double calcProbability(final double ecurrent, final double enew, final double t); int getK(); int getCycles(); void setCycles(final int cycles); String getStatus(); }
@Test public void testCoolingSchedule() { final DiscreteAnnealSubclass anneal = new DiscreteAnnealSubclass(1000, 400, 1); assertEquals(400, anneal.coolingSchedule(), AIFH.DEFAULT_PRECISION); anneal.iteration(); assertEquals(397.61057939346017, anneal.coolingSchedule(), AIFH.DEFAULT_PRECISION); }
LogitLinkFunction implements Fn { @Override public double evaluate(final double[] x) { if (x.length > 1) { throw new AIFHError("The logistic link function can only accept one parameter."); } return 1.0 / (1.0 + Math.exp(-x[0])); } @Override double evaluate(final double[] x); }
@Test public void testEvaluate() { final LogitLinkFunction fn = new LogitLinkFunction(); final double[] x = {2}; final double y = fn.evaluate(x); assertEquals(0.8807970779778823, y, AIFH.DEFAULT_PRECISION); } @Test(expected = AIFHError.class) public void testException() { final LogitLinkFunction fn = new LogitLinkFunction(); final double[] x = {1, 2}; fn.evaluate(x); }
InverseSquaredLinkFunction implements Fn { @Override public double evaluate(final double[] x) { if (x.length > 1) { throw new AIFHError("The inverse squared link function can only accept one parameter."); } return -Math.pow(x[0], -2); } @Override double evaluate(final double[] x); }
@Test public void testEvaluate() { final InverseSquaredLinkFunction fn = new InverseSquaredLinkFunction(); final double[] x = {2}; final double y = fn.evaluate(x); assertEquals(-0.25, y, AIFH.DEFAULT_PRECISION); } @Test(expected = AIFHError.class) public void testException() { final InverseSquaredLinkFunction fn = new InverseSquaredLinkFunction(); final double[] x = {1, 2}; fn.evaluate(x); }
GaussianFunction extends AbstractRBF { @Override public double evaluate(final double[] x) { double value = 0; final double width = getWidth(); for (int i = 0; i < getDimensions(); i++) { final double center = this.getCenter(i); value += Math.pow(x[i] - center, 2) / (2.0 * width * width); } return Math.exp(-value); } GaussianFunction(final int theDimensions, final double[] theParams, final int theIndex); @Override double evaluate(final double[] x); }
@Test public void testEvaluate() { final double[] params = {5, 0, 0, 0}; final GaussianFunction funct = new GaussianFunction(3, params, 0); final double[] x = {-1, 0, 1}; final double y = funct.evaluate(x); assertEquals(0.9607894391523232, y, AIFH.DEFAULT_PRECISION); } @Test public void testToString() { final double[] params = {5, 0, 0, 0}; final GaussianFunction funct = new GaussianFunction(3, params, 0); final double[] x = {-1, 0, 1}; funct.evaluate(x); assertEquals("[GaussianFunction:width=5.00,center=0.00,0.00,0.00]", funct.toString()); }
MultiquadricFunction extends AbstractRBF { @Override public double evaluate(final double[] x) { double value = 0; final double width = getWidth(); for (int i = 0; i < getDimensions(); i++) { final double center = getCenter(i); value += Math.pow(x[i] - center, 2) + (width * width); } return Math.sqrt(value); } MultiquadricFunction(final int theDimensions, final double[] theParams, final int theIndex); @Override double evaluate(final double[] x); }
@Test public void testEvaluate() { final double[] params = {5, 0, 0, 0}; final MultiquadricFunction funct = new MultiquadricFunction(3, params, 0); final double[] x = {-1, 0, 1}; final double y = funct.evaluate(x); assertEquals(8.774964387392123, y, AIFH.DEFAULT_PRECISION); } @Test public void testToString() { final double[] params = {5, 0, 0, 0}; final MultiquadricFunction funct = new MultiquadricFunction(3, params, 0); final double[] x = {-1, 0, 1}; funct.evaluate(x); assertEquals("[MultiquadricFunction:width=5.00,center=0.00,0.00,0.00]", funct.toString()); }
InverseMultiquadricFunction extends AbstractRBF { @Override public double evaluate(final double[] x) { double value = 0; final double width = getWidth(); for (int i = 0; i < getDimensions(); i++) { final double center = getCenter(i); value += Math.pow(x[i] - center, 2) + (width * width); } return 1 / Math.sqrt(value); } InverseMultiquadricFunction(final int theDimensions, final double[] theParams, final int theIndex); @Override double evaluate(final double[] x); }
@Test public void testEvaluate() { final double[] params = {5, 0, 0, 0}; final InverseMultiquadricFunction funct = new InverseMultiquadricFunction(3, params, 0); final double[] x = {-1, 0, 1}; final double y = funct.evaluate(x); assertEquals(0.11396057645963795, y, AIFH.DEFAULT_PRECISION); } @Test public void testToString() { final double[] params = {5, 0, 0, 0}; final InverseMultiquadricFunction funct = new InverseMultiquadricFunction(3, params, 0); final double[] x = {-1, 0, 1}; funct.evaluate(x); assertEquals("[InverseMultiquadricFunction:width=5.00,center=0.00,0.00,0.00]", funct.toString()); }
ScoreClassificationData implements ScoreFunction { @Override public double calculateScore(final MachineLearningAlgorithm algo) { int incorrectCount = 0; int totalCount = 0; final ClassificationAlgorithm ralgo = (ClassificationAlgorithm) algo; for (final BasicData aTrainingData : this.trainingData) { totalCount++; final int output = ralgo.computeClassification(aTrainingData.getInput()); if (output != (int) aTrainingData.getIdeal()[0]) { incorrectCount++; } } return (double) incorrectCount / (double) totalCount; } ScoreClassificationData(final List<BasicData> theTrainingData); @Override double calculateScore(final MachineLearningAlgorithm algo); }
@Test public void testClassification() { final double[] ACTUAL = {0.0, 1.0, 0.0, 0.0}; final List<BasicData> training = BasicData.convertArrays(TEST_INPUT, TEST_IDEAL); final ScoreClassificationData score = new ScoreClassificationData(training); final SimpleAlgo simple = new SimpleAlgo(ACTUAL); final double s = score.calculateScore(simple); assertEquals(0.25, s, AIFH.DEFAULT_PRECISION); }
MexicanHatFunction extends AbstractRBF { @Override public double evaluate(final double[] x) { double norm = 0; for (int i = 0; i < getDimensions(); i++) { final double center = this.getCenter(i); norm += Math.pow(x[i] - center, 2); } return (1 - norm) * Math.exp(-norm / 2); } MexicanHatFunction(final int theDimensions, final double[] theParams, final int theIndex); @Override double evaluate(final double[] x); }
@Test public void testEvaluate() { final double[] params = {5, 0, 0, 0}; final MexicanHatFunction funct = new MexicanHatFunction(3, params, 0); final double[] x = {-1, 0, 1}; final double y = funct.evaluate(x); assertEquals(-0.36787944117144233, y, AIFH.DEFAULT_PRECISION); } @Test public void testToString() { final double[] params = {5, 0, 0, 0}; final MexicanHatFunction funct = new MexicanHatFunction(3, params, 0); final double[] x = {-1, 0, 1}; funct.evaluate(x); assertEquals("[MexicanHatFunction:width=5.00,center=0.00,0.00,0.00]", funct.toString()); }
DataSet { @Override public boolean equals(final Object other) { if (!(other instanceof DataSet)) { return false; } final DataSet otherSet = (DataSet) other; if (getHeaderCount() != otherSet.getHeaderCount()) { return false; } if (size() != otherSet.size()) { return false; } for (int i = 0; i < getHeaderCount(); i++) { if (!this.headers[i].equals(otherSet.getHeaders()[i])) { return false; } } for (int i = 0; i < size(); i++) { final Object[] row1 = this.data.get(i); final Object[] row2 = ((DataSet) other).getData().get(i); for (int j = 0; j < getHeaderCount(); j++) { if (!row1[j].equals(row2[j])) { return false; } } } return true; } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testEqual() { final DataSet ds1 = generateTestData(); final DataSet ds2 = generateTestData(); assertTrue(ds1.equals(ds2)); } @Test public void testNotEqualOtherObject() { final DataSet ds1 = generateTestData(); assertFalse(ds1.equals("")); }
DataSet { public double getMin(final int column) { double result = Double.POSITIVE_INFINITY; for (final Object[] obj : this.data) { result = Math.min(result, convertNumeric(obj, column)); } return result; } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testMin() { final DataSet ds1 = generateTestData(); assertEquals(1.0, ds1.getMin(1), AIFH.DEFAULT_PRECISION); assertEquals(1.0, ds1.getMin(1), AIFH.DEFAULT_PRECISION); }
DataSet { public double getMax(final int column) { double result = Double.NEGATIVE_INFINITY; for (final Object[] obj : this.data) { result = Math.max(result, convertNumeric(obj, column)); } return result; } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testMax() { final DataSet ds1 = generateTestData(); assertEquals(3.0, ds1.getMax(1), AIFH.DEFAULT_PRECISION); assertEquals(3.0, ds1.getMax(1), AIFH.DEFAULT_PRECISION); }
DataSet { public void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh) { for (final Object[] obj : this.data) { final double x = convertNumeric(obj, column); obj[column] = ((x - dataLow) / (dataHigh - dataLow)) * (normalizedHigh - normalizedLow) + normalizedLow; } } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testNormalizeRange() { final DataSet ds1 = generateTestData(); ds1.normalizeRange(1, -1, 1); assertEquals(-1.0, Double.parseDouble(ds1.getData().get(0)[1].toString()) , AIFH.DEFAULT_PRECISION); }
DataSet { public void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh) { for (final Object[] obj : this.data) { final double x = convertNumeric(obj, column); obj[column] = ((dataLow - dataHigh) * x - normalizedHigh * dataLow + dataHigh * normalizedLow) / (normalizedLow - normalizedHigh); } } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testDeNormalizeRange() { final DataSet ds1 = generateTestData(); final double min = ds1.getMin(2); final double max = ds1.getMax(2); ds1.normalizeRange(2, min, max, -1, 1); assertEquals(-1.0, Double.parseDouble(ds1.getData().get(0)[2].toString()) , AIFH.DEFAULT_PRECISION); ds1.deNormalizeRange(2, min, max, -1, 1); assertEquals(0.1, Double.parseDouble(ds1.getData().get(0)[2].toString()) , AIFH.DEFAULT_PRECISION); }
DataSet { public void normalizeReciprocal(final int column) { for (final Object[] obj : this.data) { final double x = convertNumeric(obj, column); obj[column] = 1 / x; } } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testNormalizeReciprocal() { final DataSet ds1 = generateTestData(); ds1.normalizeReciprocal(1); assertEquals(0.5, Double.parseDouble(ds1.getData().get(1)[1].toString()) , AIFH.DEFAULT_PRECISION); ds1.deNormalizeReciprocal(1); assertEquals(2.0, Double.parseDouble(ds1.getData().get(1)[1].toString()) , AIFH.DEFAULT_PRECISION); }
DataSet { public Map<String, Integer> encodeNumeric(final int column) { final Map<String, Integer> classes = enumerateClasses(column); for (final Object[] obj : this.data) { final int index = classes.get(obj[column].toString()); obj[column] = index; } return classes; } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testEncodeNumeric() { final DataSet ds1 = generateTestData(); ds1.encodeNumeric(0); }
RBFNetwork implements RegressionAlgorithm, ClassificationAlgorithm { @Override public double[] computeRegression(final double[] input) { final double[] rbfOutput = new double[rbf.length + 1]; rbfOutput[rbfOutput.length - 1] = 1; for (int rbfIndex = 0; rbfIndex < rbf.length; rbfIndex++) { final double[] weightedInput = new double[input.length]; for (int inputIndex = 0; inputIndex < input.length; inputIndex++) { final int memoryIndex = this.indexInputWeights + (rbfIndex * this.inputCount) + inputIndex; weightedInput[inputIndex] = input[inputIndex] * this.longTermMemory[memoryIndex]; } rbfOutput[rbfIndex] = this.rbf[rbfIndex].evaluate(weightedInput); } final double[] result = new double[this.outputCount]; for (int outputIndex = 0; outputIndex < result.length; outputIndex++) { double sum = 0; for (int rbfIndex = 0; rbfIndex < rbfOutput.length; rbfIndex++) { final int memoryIndex = this.indexOutputWeights + (outputIndex * (rbf.length + 1)) + rbfIndex; sum += rbfOutput[rbfIndex] * this.longTermMemory[memoryIndex]; } result[outputIndex] = sum; } return result; } RBFNetwork(final int theInputCount, final int rbfCount, final int theOutputCount); @Override double[] computeRegression(final double[] input); @Override double[] getLongTermMemory(); void reset(final GenerateRandom rnd); @Override int computeClassification(final double[] input); @Override String toString(); }
@Test public void testComputeRegression() { final RBFNetwork network = new RBFNetwork(2, 1, 1); final double[] ltm = { 2.0, 2.0, 5.0, 2.0, 4.0, 3.0, 4.0}; System.arraycopy(ltm, 0, network.getLongTermMemory(), 0, ltm.length); final double[] x = {1, 2}; final double y = network.computeRegression(x)[0]; assertEquals(7, y, AIFH.DEFAULT_PRECISION); }
DataSet { public Map<String, Integer> encodeOneOfN(final int column) { return encodeOneOfN(column, 0, 1); } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testEncodeOneOfN() { final DataSet ds1 = generateTestData(); ds1.encodeOneOfN(0); }
DataSet { public Map<String, Integer> encodeEquilateral(final int column) { return encodeEquilateral(column, 0, 1); } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testEncodeEquilateral() { final DataSet ds1 = generateTestData(); ds1.encodeEquilateral(0,-1,1); assertEquals(4,ds1.getHeaderCount()); Set<Double> col1=new HashSet<>(); Set<Double> col2=new HashSet<>(); for (Object[] row:ds1.getData()){ col1.add(round((Double)row[0])); col2.add(round((Double)row[1])); } Set<Double> expected1=new HashSet<>(Arrays.<Double>asList(0.0,-0.866,0.866)); Set<Double> expected2=new HashSet<>(Arrays.<Double>asList(1.0,-0.5)); assertEquals(expected1,col1); assertEquals(expected2,col2); }
DataSet { public void deleteColumn(final int col) { final String[] headers2 = new String[headers.length - 1]; int h2Index = 0; for (int i = 0; i < headers.length; i++) { if (i != col) { headers2[h2Index++] = headers[i]; } } this.headers = headers2; int rowIndex = 0; for (final Object[] row : this.data) { final Object[] row2 = new Object[headers.length]; int r2Index = 0; for (int i = 0; i <= headers.length; i++) { if (i != col) { row2[r2Index++] = row[i]; } } this.data.set(rowIndex++, row2); } } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testDeleteColumn() { final DataSet ds1 = generateTestData(); ds1.deleteColumn(0); assertEquals(2, ds1.getHeaderCount()); assertTrue(ds1.getHeaders()[0].equals("numeric")); assertTrue(ds1.getHeaders()[1].equals("dec")); }
DataSet { public List<BasicData> extractUnsupervisedLabeled(final int labelIndex) { final List<BasicData> result = new ArrayList<BasicData>(); final int dimensions = getHeaderCount() - 1; for (int rowIndex = 0; rowIndex < size(); rowIndex++) { final Object[] raw = this.data.get(rowIndex); final BasicData row = new BasicData(dimensions, 0, raw[labelIndex].toString()); int colIndex = 0; for (int rawColIndex = 0; rawColIndex < getHeaderCount(); rawColIndex++) { if (rawColIndex != labelIndex) { row.getInput()[colIndex++] = convertNumeric(raw, rawColIndex); } } result.add(row); } return result; } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testExtractUnsupervisedLabeled() { final DataSet ds1 = generateTestData(); final List<BasicData> result = ds1.extractUnsupervisedLabeled(0); assertEquals(3, result.size()); assertTrue(result.get(0).getLabel().equals("One")); }
DataSet { public List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount) { final List<BasicData> result = new ArrayList<BasicData>(); for (int rowIndex = 0; rowIndex < size(); rowIndex++) { final Object[] raw = this.data.get(rowIndex); final BasicData row = new BasicData(inputCount, idealCount); for (int i = 0; i < inputCount; i++) { row.getInput()[i] = convertNumeric(raw, inputBegin + i); } for (int i = 0; i < idealCount; i++) { row.getIdeal()[i] = convertNumeric(raw, idealBegin + i); } result.add(row); } return result; } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testExtractSupervised() { final DataSet ds1 = generateTestData(); final List<BasicData> result = ds1.extractSupervised(1, 1, 2, 1); assertEquals(3, result.size()); }
DataSet { public void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others) { for (final Object[] row : this.data) { final double d = convertNumeric(row, columnIndex); if (Math.abs(d - searchFor) < 0.0001) { row[columnIndex] = replaceWith; } else { row[columnIndex] = others; } } } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testReplaceColumn() { final DataSet ds1 = generateTestData(); ds1.replaceColumn(1, 2, 1, 0); final List<BasicData> result = ds1.extractSupervised(1, 1, 2, 1); assertEquals(0.0, result.get(0).getInput()[0], AIFH.DEFAULT_PRECISION); assertEquals(1.0, result.get(1).getInput()[0], AIFH.DEFAULT_PRECISION); }
DataSet { public void deleteUnknowns() { int rowIndex = 0; while (rowIndex < this.data.size()) { final Object[] row = data.get(rowIndex); boolean remove = false; for (final Object aRow : row) { if (aRow.toString().equals("?")) { remove = true; break; } } if (remove) { data.remove(rowIndex); } else { rowIndex++; } } } DataSet(final String[] theHeaders); static DataSet load(final File filename); static DataSet load(final InputStream is); static void save(final File filename, final DataSet ds); static void save(final OutputStream os, final DataSet ds); int getHeaderCount(); String[] getHeaders(); void add(final Object[] row); List<Object[]> getData(); double getMax(final int column); double getMin(final int column); void normalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeRange(final int column, final double normalizedLow, final double normalizedHigh); void deNormalizeRange(final int column, final double dataLow, final double dataHigh, final double normalizedLow, final double normalizedHigh); void normalizeReciprocal(final int column); void deNormalizeReciprocal(final int column); Map<String, Integer> enumerateClasses(final int column); Map<String, Integer> encodeNumeric(final int column); Map<String, Integer> encodeOneOfN(final int column); Map<String, Integer> encodeOneOfN(final int column, final double offValue, final double onValue); Map<String, Integer> encodeEquilateral(final int column); Map<String, Integer> encodeEquilateral(final int column, final double offValue, final double onValue); int size(); void appendColumns(final int count); void insertColumns(final int column, final int columnCount); @Override boolean equals(final Object other); List<BasicData> extractUnsupervisedLabeled(final int labelIndex); List<BasicData> extractSupervised(final int inputBegin, final int inputCount, final int idealBegin, final int idealCount); void deleteUnknowns(); void deleteColumn(final int col); void replaceColumn(final int columnIndex, final double searchFor, final double replaceWith, final double others); }
@Test public void testDeleteUnknowns() { final DataSet ds1 = generateTestData(); ds1.getData().get(1)[2] = "?"; ds1.deleteUnknowns(); assertEquals(2, ds1.getData().size()); }
Equilateral implements Serializable { public final double[] encode(final int set) { if (set < 0 || set > this.matrix.length) { throw new AIFHError("Class out of range for equilateral: " + set); } return this.matrix[set]; } Equilateral(final int count, final double low, final double high); final int decode(final double[] activations); final double[] encode(final int set); final double getDistance(final double[] data, final int set); static final int MIN_EQ; }
@Test public void testEncode() { final Equilateral eq = new Equilateral(3, -1, 1); final double[] d = eq.encode(1); assertEquals(0.8660254037844386, d[0], AIFH.DEFAULT_PRECISION); assertEquals(-0.5, d[1], AIFH.DEFAULT_PRECISION); } @Test(expected = AIFHError.class) public void testError() { final Equilateral eq = new Equilateral(3, -1, 1); eq.encode(10); } @Test public void testAllEqual() { final Equilateral eq = new Equilateral(10, -1, 1); final CalculateDistance dc = new EuclideanDistance(); double compareDist = 0; for (int x = 0; x < 10; x++) { double[] baseClass = eq.encode(x); for (int y = 0; y < 10; y++) { if (x != y) { double[] otherClass = eq.encode(y); double dist = dc.calculate(baseClass, otherClass); if (compareDist < AIFH.DEFAULT_PRECISION) { compareDist = dist; } else { assertEquals(compareDist, dist, AIFH.DEFAULT_PRECISION); } } } } }
Equilateral implements Serializable { public final int decode(final double[] activations) { double minValue = Double.POSITIVE_INFINITY; int minSet = -1; for (int i = 0; i < this.matrix.length; i++) { final double dist = getDistance(activations, i); if (dist < minValue) { minValue = dist; minSet = i; } } return minSet; } Equilateral(final int count, final double low, final double high); final int decode(final double[] activations); final double[] encode(final int set); final double getDistance(final double[] data, final int set); static final int MIN_EQ; }
@Test public void testDecode() { final Equilateral eq = new Equilateral(3, -1, 1); final double[] d0 = {0.866, 0.5}; final double[] d1 = {-0.866, 0.5}; final double[] d2 = {0, -1}; assertEquals(2, eq.decode(d0)); assertEquals(2, eq.decode(d1)); assertEquals(0, eq.decode(d2)); }
RBFNetwork implements RegressionAlgorithm, ClassificationAlgorithm { @Override public int computeClassification(final double[] input) { final double[] output = computeRegression(input); return VectorUtil.maxIndex(output); } RBFNetwork(final int theInputCount, final int rbfCount, final int theOutputCount); @Override double[] computeRegression(final double[] input); @Override double[] getLongTermMemory(); void reset(final GenerateRandom rnd); @Override int computeClassification(final double[] input); @Override String toString(); }
@Test public void testComputeClassification() { final RBFNetwork network = new RBFNetwork(2, 1, 2); final double[] ltm = { 2.0, 2.0, 5.0, 2.0, 4.0, 3.0, 4.0, 5.0, 6.0}; System.arraycopy(ltm, 0, network.getLongTermMemory(), 0, ltm.length); final double[] x = {1, 2}; final double[] y = network.computeRegression(x); assertEquals(7, y[0], AIFH.DEFAULT_PRECISION); assertEquals(11, y[1], AIFH.DEFAULT_PRECISION); final int cls = network.computeClassification(x); assertEquals(1, cls); }
BasicGenerateRandom extends AbstractGenerateRandom { @Override public boolean nextBoolean() { return this.rand.nextBoolean(); } BasicGenerateRandom(final long seed); BasicGenerateRandom(); @Override int nextInt(); @Override double nextDouble(); @Override float nextFloat(); @Override long nextLong(); @Override boolean nextBoolean(); @Override double nextGaussian(); }
@Test public void testGenerateBoolean() { final BasicGenerateRandom rnd = new BasicGenerateRandom(1); for (final boolean aBOOLEAN_TEST : BOOLEAN_TEST) { final boolean g = rnd.nextBoolean(); assertEquals(g, aBOOLEAN_TEST); } }
BasicGenerateRandom extends AbstractGenerateRandom { @Override public double nextDouble() { return this.rand.nextDouble(); } BasicGenerateRandom(final long seed); BasicGenerateRandom(); @Override int nextInt(); @Override double nextDouble(); @Override float nextFloat(); @Override long nextLong(); @Override boolean nextBoolean(); @Override double nextGaussian(); }
@Test public void testDoubleRange() { final BasicGenerateRandom rnd = new BasicGenerateRandom(1); for (final double aDOUBLE_RANGE_TEST : DOUBLE_RANGE_TEST) { final double g = rnd.nextDouble(-1, 1); assertEquals(g, aDOUBLE_RANGE_TEST, AIFH.DEFAULT_PRECISION); } } @Test public void testDouble() { final BasicGenerateRandom rnd = new BasicGenerateRandom(1); for (final double aDOUBLE_TEST : DOUBLE_TEST) { final double g = rnd.nextDouble(); assertEquals(g, aDOUBLE_TEST, AIFH.DEFAULT_PRECISION); } }
BasicGenerateRandom extends AbstractGenerateRandom { @Override public long nextLong() { return this.rand.nextLong(); } BasicGenerateRandom(final long seed); BasicGenerateRandom(); @Override int nextInt(); @Override double nextDouble(); @Override float nextFloat(); @Override long nextLong(); @Override boolean nextBoolean(); @Override double nextGaussian(); }
@Test public void testLong() { final BasicGenerateRandom rnd = new BasicGenerateRandom(1); for (final long aLONG_TEST : LONG_TEST) { final long l = rnd.nextLong(); assertEquals(l, aLONG_TEST, AIFH.DEFAULT_PRECISION); } }
BasicGenerateRandom extends AbstractGenerateRandom { @Override public float nextFloat() { return this.rand.nextFloat(); } BasicGenerateRandom(final long seed); BasicGenerateRandom(); @Override int nextInt(); @Override double nextDouble(); @Override float nextFloat(); @Override long nextLong(); @Override boolean nextBoolean(); @Override double nextGaussian(); }
@Test public void testFloat() { final BasicGenerateRandom rnd = new BasicGenerateRandom(1); for (final float aFLOAT_TEST : FLOAT_TEST) { final float l = (float) rnd.nextFloat(); assertEquals(l, aFLOAT_TEST, AIFH.DEFAULT_PRECISION); } }
BasicGenerateRandom extends AbstractGenerateRandom { @Override public double nextGaussian() { return this.rand.nextGaussian(); } BasicGenerateRandom(final long seed); BasicGenerateRandom(); @Override int nextInt(); @Override double nextDouble(); @Override float nextFloat(); @Override long nextLong(); @Override boolean nextBoolean(); @Override double nextGaussian(); }
@Test public void testGaussianFloat() { final BasicGenerateRandom rnd = new BasicGenerateRandom(1); for (final double aGAUSSIAN_TEST : GAUSSIAN_TEST) { final double g = rnd.nextGaussian(); assertEquals(g, aGAUSSIAN_TEST, AIFH.DEFAULT_PRECISION); } }
BasicGenerateRandom extends AbstractGenerateRandom { @Override public int nextInt() { return this.rand.nextInt(); } BasicGenerateRandom(final long seed); BasicGenerateRandom(); @Override int nextInt(); @Override double nextDouble(); @Override float nextFloat(); @Override long nextLong(); @Override boolean nextBoolean(); @Override double nextGaussian(); }
@Test public void testInt() { final BasicGenerateRandom rnd = new BasicGenerateRandom(1); for (final int aINT_TEST : INT_TEST) { final int g = rnd.nextInt(); assertEquals(g, aINT_TEST, AIFH.DEFAULT_PRECISION); } } @Test public void testIntRange() { final BasicGenerateRandom rnd = new BasicGenerateRandom(1); for (final int aINT_RANGE_TEST : INT_RANGE_TEST) { final int g = rnd.nextInt(0, 10); assertEquals(g, aINT_RANGE_TEST); } }
MultiplyWithCarryGenerateRandom extends AbstractBoxMuller { @Override public boolean nextBoolean() { return nextDouble() > 0.5; } MultiplyWithCarryGenerateRandom(final long seed); MultiplyWithCarryGenerateRandom(); MultiplyWithCarryGenerateRandom(long[] seeds, final long carry, final int r, final long multiplier); @Override double nextDouble(); @Override long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }
@Test public void testGenerateBoolean() { final MultiplyWithCarryGenerateRandom rnd = new MultiplyWithCarryGenerateRandom(1); for (final boolean aBOOLEAN_TEST : BOOLEAN_TEST) { final boolean g = rnd.nextBoolean(); assertEquals(g, aBOOLEAN_TEST); } }
ChebyshevDistance extends AbstractDistance { @Override public double calculate(final double[] position1, final int pos1, final double[] position2, final int pos2, final int length) { double result = 0; for (int i = 0; i < length; i++) { final double d = Math.abs(position1[pos1 + i] - position2[pos2 + i]); result = Math.max(d, result); } return result; } @Override double calculate(final double[] position1, final int pos1, final double[] position2, final int pos2, final int length); }
@Test public void testDistanceCalc() { final CalculateDistance calc = new ChebyshevDistance(); final double[] pos1 = {0.5, 1.0, 2.5,}; final double[] pos2 = {0.1, 2.0, -2.5,}; assertEquals(5.0, calc.calculate(pos1, pos2), 0.001); }
MultiplyWithCarryGenerateRandom extends AbstractBoxMuller { @Override public double nextDouble() { return (((long) next(26) << 27) + next(27)) / (double) (1L << 53); } MultiplyWithCarryGenerateRandom(final long seed); MultiplyWithCarryGenerateRandom(); MultiplyWithCarryGenerateRandom(long[] seeds, final long carry, final int r, final long multiplier); @Override double nextDouble(); @Override long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }
@Test public void testDoubleRange() { final MultiplyWithCarryGenerateRandom rnd = new MultiplyWithCarryGenerateRandom(1); for (final double aDOUBLE_RANGE_TEST : DOUBLE_RANGE_TEST) { final double g = rnd.nextDouble(-1, 1); assertEquals(g, aDOUBLE_RANGE_TEST, AIFH.DEFAULT_PRECISION); } } @Test public void testDouble() { final MultiplyWithCarryGenerateRandom rnd = new MultiplyWithCarryGenerateRandom(1); for (final double aDOUBLE_TEST : DOUBLE_TEST) { final double g = rnd.nextDouble(); assertEquals(g, aDOUBLE_TEST, AIFH.DEFAULT_PRECISION); } }
MultiplyWithCarryGenerateRandom extends AbstractBoxMuller { @Override public long nextLong() { return ((long) next(32) << 32) + next(32); } MultiplyWithCarryGenerateRandom(final long seed); MultiplyWithCarryGenerateRandom(); MultiplyWithCarryGenerateRandom(long[] seeds, final long carry, final int r, final long multiplier); @Override double nextDouble(); @Override long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }
@Test public void testLong() { final MultiplyWithCarryGenerateRandom rnd = new MultiplyWithCarryGenerateRandom(1); for (final long aLONG_TEST : LONG_TEST) { final long l = rnd.nextLong(); assertEquals(l, aLONG_TEST); } }
MultiplyWithCarryGenerateRandom extends AbstractBoxMuller { @Override public float nextFloat() { return (float) nextDouble(); } MultiplyWithCarryGenerateRandom(final long seed); MultiplyWithCarryGenerateRandom(); MultiplyWithCarryGenerateRandom(long[] seeds, final long carry, final int r, final long multiplier); @Override double nextDouble(); @Override long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }
@Test public void testFloat() { final MultiplyWithCarryGenerateRandom rnd = new MultiplyWithCarryGenerateRandom(1); for (final float aFLOAT_TEST : FLOAT_TEST) { final float l = (float) rnd.nextFloat(); assertEquals(l, aFLOAT_TEST, AIFH.DEFAULT_PRECISION); } }
MultiplyWithCarryGenerateRandom extends AbstractBoxMuller { @Override public int nextInt() { return (int) nextLong(); } MultiplyWithCarryGenerateRandom(final long seed); MultiplyWithCarryGenerateRandom(); MultiplyWithCarryGenerateRandom(long[] seeds, final long carry, final int r, final long multiplier); @Override double nextDouble(); @Override long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }
@Test public void testInt() { final MultiplyWithCarryGenerateRandom rnd = new MultiplyWithCarryGenerateRandom(1); for (final int aINT_TEST : INT_TEST) { final int g = rnd.nextInt(); assertEquals(g, aINT_TEST); } } @Test public void testIntRange() { final MultiplyWithCarryGenerateRandom rnd = new MultiplyWithCarryGenerateRandom(1); for (final int aINT_RANGE_TEST : INT_RANGE_TEST) { final int g = rnd.nextInt(0, 10); assertEquals(g, aINT_RANGE_TEST); } }
LinearCongruentialRandom extends AbstractBoxMuller { @Override public boolean nextBoolean() { return nextDouble() > 0.5; } LinearCongruentialRandom(final long theSeed); LinearCongruentialRandom(); LinearCongruentialRandom(final long theModulus, final long theMultiplier, final long theIncrement, final long theSeed); final long getIncrement(); final long getModulus(); final long getMultiplier(); final long getSeed(); @Override final double nextDouble(); @Override final long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); static final long DEFAULT_MOD1; static final long DEFAULT_MOD2; static final long DEFAULT_MULT; static final long DEFAULT_INC; static final long MAX_RAND; }
@Test public void testGenerateBoolean() { final LinearCongruentialRandom rnd = new LinearCongruentialRandom(1); for (final boolean aBOOLEAN_TEST : BOOLEAN_TEST) { final boolean g = rnd.nextBoolean(); assertEquals(g, aBOOLEAN_TEST); } }
LinearCongruentialRandom extends AbstractBoxMuller { @Override public final double nextDouble() { return (double) nextLong() / LinearCongruentialRandom.MAX_RAND; } LinearCongruentialRandom(final long theSeed); LinearCongruentialRandom(); LinearCongruentialRandom(final long theModulus, final long theMultiplier, final long theIncrement, final long theSeed); final long getIncrement(); final long getModulus(); final long getMultiplier(); final long getSeed(); @Override final double nextDouble(); @Override final long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); static final long DEFAULT_MOD1; static final long DEFAULT_MOD2; static final long DEFAULT_MULT; static final long DEFAULT_INC; static final long MAX_RAND; }
@Test public void testDoubleRange() { final LinearCongruentialRandom rnd = new LinearCongruentialRandom(1); for (final double aDOUBLE_RANGE_TEST : DOUBLE_RANGE_TEST) { final double g = rnd.nextDouble(-1, 1); assertEquals(g, aDOUBLE_RANGE_TEST, AIFH.DEFAULT_PRECISION); } } @Test public void testDouble() { final LinearCongruentialRandom rnd = new LinearCongruentialRandom(1); for (final double aDOUBLE_TEST : DOUBLE_TEST) { final double g = rnd.nextDouble(); assertEquals(g, aDOUBLE_TEST, AIFH.DEFAULT_PRECISION); } }
LinearCongruentialRandom extends AbstractBoxMuller { @Override public final long nextLong() { this.seed = (this.multiplier * this.seed + this.increment) % this.modulus; return this.seed; } LinearCongruentialRandom(final long theSeed); LinearCongruentialRandom(); LinearCongruentialRandom(final long theModulus, final long theMultiplier, final long theIncrement, final long theSeed); final long getIncrement(); final long getModulus(); final long getMultiplier(); final long getSeed(); @Override final double nextDouble(); @Override final long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); static final long DEFAULT_MOD1; static final long DEFAULT_MOD2; static final long DEFAULT_MULT; static final long DEFAULT_INC; static final long MAX_RAND; }
@Test public void testLong() { final LinearCongruentialRandom rnd = new LinearCongruentialRandom(1); for (final long aLONG_TEST : LONG_TEST) { final long l = rnd.nextLong(); assertEquals(l, aLONG_TEST, AIFH.DEFAULT_PRECISION); } }
EuclideanDistance extends AbstractDistance { @Override public double calculate(final double[] position1, final int pos1, final double[] position2, final int pos2, final int length) { double sum = 0; for (int i = 0; i < length; i++) { final double d = position1[i + pos1] - position2[i + pos1]; sum += d * d; } return Math.sqrt(sum); } @Override double calculate(final double[] position1, final int pos1, final double[] position2, final int pos2, final int length); }
@Test public void testDistanceCalc() { final CalculateDistance calc = new EuclideanDistance(); final double[] pos1 = {0.5, 1.0, 2.5,}; final double[] pos2 = {0.1, 2.0, -2.5,}; assertEquals(5.1146, calc.calculate(pos1, pos2), 0.001); }
LinearCongruentialRandom extends AbstractBoxMuller { @Override public float nextFloat() { return (float) nextDouble(); } LinearCongruentialRandom(final long theSeed); LinearCongruentialRandom(); LinearCongruentialRandom(final long theModulus, final long theMultiplier, final long theIncrement, final long theSeed); final long getIncrement(); final long getModulus(); final long getMultiplier(); final long getSeed(); @Override final double nextDouble(); @Override final long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); static final long DEFAULT_MOD1; static final long DEFAULT_MOD2; static final long DEFAULT_MULT; static final long DEFAULT_INC; static final long MAX_RAND; }
@Test public void testFloat() { final LinearCongruentialRandom rnd = new LinearCongruentialRandom(1); for (final float aFLOAT_TEST : FLOAT_TEST) { final float l = (float) rnd.nextFloat(); assertEquals(l, aFLOAT_TEST, AIFH.DEFAULT_PRECISION); } }
LinearCongruentialRandom extends AbstractBoxMuller { @Override public int nextInt() { return (int) nextLong(); } LinearCongruentialRandom(final long theSeed); LinearCongruentialRandom(); LinearCongruentialRandom(final long theModulus, final long theMultiplier, final long theIncrement, final long theSeed); final long getIncrement(); final long getModulus(); final long getMultiplier(); final long getSeed(); @Override final double nextDouble(); @Override final long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); static final long DEFAULT_MOD1; static final long DEFAULT_MOD2; static final long DEFAULT_MULT; static final long DEFAULT_INC; static final long MAX_RAND; }
@Test public void testInt() { final LinearCongruentialRandom rnd = new LinearCongruentialRandom(1); for (final int aINT_TEST : INT_TEST) { final int g = rnd.nextInt(); assertEquals(g, aINT_TEST, AIFH.DEFAULT_PRECISION); } } @Test public void testIntRange() { final LinearCongruentialRandom rnd = new LinearCongruentialRandom(1); for (final int aINT_RANGE_TEST : INT_RANGE_TEST) { final int g = rnd.nextInt(0, 10); assertEquals(g, aINT_RANGE_TEST); } }
MersenneTwisterGenerateRandom extends AbstractBoxMuller { @Override public double nextDouble() { return (((long) next(26) << 27) + next(27)) / (double) (1L << 53); } MersenneTwisterGenerateRandom(); MersenneTwisterGenerateRandom(final long seed); MersenneTwisterGenerateRandom(final int[] array); void setSeed(final long seed); void setSeed(final int[] array); @Override double nextDouble(); long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }
@Test public void testBasic() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); assertEquals(4.1702200468159925, rnd.nextDouble(10), AIFH.DEFAULT_PRECISION); } @Test public void testBasic2() { final int[] seed = {1, 2, 3}; final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(seed); assertEquals(6.09861274980219, rnd.nextDouble(10), AIFH.DEFAULT_PRECISION); } @Test public void testDoubleRange() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final double aDOUBLE_RANGE_TEST : DOUBLE_RANGE_TEST) { final double g = rnd.nextDouble(-1, 1); assertEquals(g, aDOUBLE_RANGE_TEST, AIFH.DEFAULT_PRECISION); } } @Test public void testDouble() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final double aDOUBLE_TEST : DOUBLE_TEST) { final double g = rnd.nextDouble(); assertEquals(g, aDOUBLE_TEST, AIFH.DEFAULT_PRECISION); } }
MersenneTwisterGenerateRandom extends AbstractBoxMuller { @Override public boolean nextBoolean() { return nextDouble() > 0.5; } MersenneTwisterGenerateRandom(); MersenneTwisterGenerateRandom(final long seed); MersenneTwisterGenerateRandom(final int[] array); void setSeed(final long seed); void setSeed(final int[] array); @Override double nextDouble(); long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }
@Test public void testGenerateBoolean() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final boolean aBOOLEAN_TEST : BOOLEAN_TEST) { final boolean g = rnd.nextBoolean(); assertEquals(g, aBOOLEAN_TEST); } }
MersenneTwisterGenerateRandom extends AbstractBoxMuller { public long nextLong() { return ((long) next(32) << 32) + next(32); } MersenneTwisterGenerateRandom(); MersenneTwisterGenerateRandom(final long seed); MersenneTwisterGenerateRandom(final int[] array); void setSeed(final long seed); void setSeed(final int[] array); @Override double nextDouble(); long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }
@Test public void testLong() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final long aLONG_TEST : LONG_TEST) { final long l = rnd.nextLong(); assertEquals(l, aLONG_TEST); } }
MersenneTwisterGenerateRandom extends AbstractBoxMuller { @Override public float nextFloat() { return (float) nextDouble(); } MersenneTwisterGenerateRandom(); MersenneTwisterGenerateRandom(final long seed); MersenneTwisterGenerateRandom(final int[] array); void setSeed(final long seed); void setSeed(final int[] array); @Override double nextDouble(); long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }
@Test public void testFloat() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final float aFLOAT_TEST : FLOAT_TEST) { final float l = (float) rnd.nextFloat(); assertEquals(l, aFLOAT_TEST, AIFH.DEFAULT_PRECISION); } }
ManhattanDistance extends AbstractDistance { @Override public double calculate(final double[] position1, final int pos1, final double[] position2, final int pos2, final int length) { double sum = 0; for (int i = 0; i < length; i++) { final double d = Math.abs(position1[pos1 + i] - position2[pos1 + i]); sum += d; } return sum; } @Override double calculate(final double[] position1, final int pos1, final double[] position2, final int pos2, final int length); }
@Test public void testDistanceCalc() { final CalculateDistance calc = new ManhattanDistance(); final double[] pos1 = {0.5, 1.0, 2.5,}; final double[] pos2 = {0.1, 2.0, -2.5,}; assertEquals(6.4, calc.calculate(pos1, pos2), 0.001); }
MersenneTwisterGenerateRandom extends AbstractBoxMuller { @Override public int nextInt() { return (int) nextLong(); } MersenneTwisterGenerateRandom(); MersenneTwisterGenerateRandom(final long seed); MersenneTwisterGenerateRandom(final int[] array); void setSeed(final long seed); void setSeed(final int[] array); @Override double nextDouble(); long nextLong(); @Override boolean nextBoolean(); @Override float nextFloat(); @Override int nextInt(); }
@Test public void testInt() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final int aINT_TEST : INT_TEST) { final int g = rnd.nextInt(); assertEquals(g, aINT_TEST); } } @Test public void testIntRange() { final MersenneTwisterGenerateRandom rnd = new MersenneTwisterGenerateRandom(1); for (final int aINT_RANGE_TEST : INT_RANGE_TEST) { final int g = rnd.nextInt(0, 10); assertEquals(g, aINT_RANGE_TEST); } }
BasicNetwork implements RegressionAlgorithm, ClassificationAlgorithm { public double getWeight(final int fromLayer, final int fromNeuron, final int toNeuron) { validateNeuron(fromLayer, fromNeuron); validateNeuron(fromLayer + 1, toNeuron); final int fromLayerNumber = this.layers.size() - fromLayer - 1; final int toLayerNumber = fromLayerNumber - 1; if (toLayerNumber < 0) { throw new AIFHError( "The specified layer is not connected to another layer: " + fromLayer); } final int weightBaseIndex = this.layers.get(fromLayer+1).getWeightIndex(); final int count = this.layers.get(fromLayer).getTotalCount(); final int weightIndex = weightBaseIndex + fromNeuron + (toNeuron * count); return this.weights[weightIndex]; } BasicNetwork(); void compute(final double[] input, final double[] output); int getNeuronCount(); int getEncodeLength(); int getInputCount(); double[] getLayerOutput(); int getOutputCount(); double[] getWeights(); void setInputCount(final int inputCount); void setOutputCount(final int outputCount); double[] getLayerSums(); double getWeight(final int fromLayer, final int fromNeuron, final int toNeuron); void validateNeuron(final int targetLayer, final int neuron); int getLayerTotalNeuronCount(final int l); void addLayer(Layer layer); void finalizeStructure(); void clearOutput(); void setWeight(final int fromLayer, final int fromNeuron, final int toNeuron, final double value); void reset(); List<Layer> getLayers(); @Override double[] computeRegression(double[] input); @Override double[] getLongTermMemory(); Layer getNextLayer(Layer layer); Layer getPreviousLayer(Layer layer); @Override int computeClassification(double[] input); boolean isNetworkTraining(); void setNetworkTraining(boolean networkTraining); }
@Test public void testWeightAccess() { BasicNetwork network = TestBasicNetwork.buildSimpleXOR(); Assert.assertEquals(-0.48463710059519793,network.getWeight(0,0,0), AIFH.DEFAULT_PRECISION); Assert.assertEquals(0.8420570357334933,network.getWeight(0,0,1), AIFH.DEFAULT_PRECISION); Assert.assertEquals(-0.5286518143323836,network.getWeight(0,0,2), AIFH.DEFAULT_PRECISION); Assert.assertEquals(-0.9318070094873679,network.getWeight(0,1,0), AIFH.DEFAULT_PRECISION); Assert.assertEquals(-0.38185835475610996,network.getWeight(0,1,1), AIFH.DEFAULT_PRECISION); Assert.assertEquals(-0.5337936066868234,network.getWeight(0,1,2), AIFH.DEFAULT_PRECISION); Assert.assertEquals(-0.38468537605011033,network.getWeight(0,2,0), AIFH.DEFAULT_PRECISION); Assert.assertEquals(-0.06280032523507262,network.getWeight(0,2,1), AIFH.DEFAULT_PRECISION); Assert.assertEquals(-0.7822212804533125,network.getWeight(0,2,2), AIFH.DEFAULT_PRECISION); Assert.assertEquals(0.13864904435785697,network.getWeight(1,0,0), AIFH.DEFAULT_PRECISION); Assert.assertEquals(-0.1389734035215744,network.getWeight(1,1,0), AIFH.DEFAULT_PRECISION); Assert.assertEquals(0.34318625259753,network.getWeight(1,2,0), AIFH.DEFAULT_PRECISION); } @Test public void testWeightRange() { BasicNetwork network = TestBasicNetwork.buildSimpleXOR(); try { network.getWeight(2, 0, 0); Assert.assertTrue(false); } catch(AIFHError ex) { Assert.assertNotNull(ex); } try { network.getWeight(0, 3, 0); Assert.assertTrue(false); } catch(AIFHError ex) { Assert.assertNotNull(ex); } try { network.getWeight(0, 0, 4); Assert.assertTrue(false); } catch(AIFHError ex) { Assert.assertNotNull(ex); } }
BasicNetwork implements RegressionAlgorithm, ClassificationAlgorithm { @Override public double[] computeRegression(double[] input) { if( input.length!=getInputCount()) { throw new AIFHError("Invalid input count("+ input.length+"), this network is designed for: " + getInputCount()); } double[] output = new double[getOutputCount()]; compute(input,output); return output; } BasicNetwork(); void compute(final double[] input, final double[] output); int getNeuronCount(); int getEncodeLength(); int getInputCount(); double[] getLayerOutput(); int getOutputCount(); double[] getWeights(); void setInputCount(final int inputCount); void setOutputCount(final int outputCount); double[] getLayerSums(); double getWeight(final int fromLayer, final int fromNeuron, final int toNeuron); void validateNeuron(final int targetLayer, final int neuron); int getLayerTotalNeuronCount(final int l); void addLayer(Layer layer); void finalizeStructure(); void clearOutput(); void setWeight(final int fromLayer, final int fromNeuron, final int toNeuron, final double value); void reset(); List<Layer> getLayers(); @Override double[] computeRegression(double[] input); @Override double[] getLongTermMemory(); Layer getNextLayer(Layer layer); Layer getPreviousLayer(Layer layer); @Override int computeClassification(double[] input); boolean isNetworkTraining(); void setNetworkTraining(boolean networkTraining); }
@Test public void testCalculate() { BasicNetwork network = TestBasicNetwork.buildSimpleXOR(); double[] out1 = network.computeRegression(new double[] {0.0, 0.0}); Assert.assertEquals(0.34688637738116557, out1[0], AIFH.DEFAULT_PRECISION); double[] out2 = network.computeRegression(new double[] {1.0, 0.0}); Assert.assertEquals(0.32943376685512565, out2[0], AIFH.DEFAULT_PRECISION); Assert.assertEquals(1,out2.length); }
XaiverRandomizeNetwork extends AbstractRandomizeNetwork { @Override public void randomize(BasicNetwork network) { for (int i = 0; i < network.getLayers().size() - 1; i++) { randomizeLayer(network, i); } } @Override void randomize(BasicNetwork network); }
@Test public void testRandomize() { BasicNetwork network = new BasicNetwork(); network.addLayer(new BasicLayer(null,true,2)); network.addLayer(new BasicLayer(new ActivationSigmoid(),true,3)); network.addLayer(new BasicLayer(new ActivationSigmoid(),false,1)); network.finalizeStructure(); XaiverRandomizeNetwork randomize = new XaiverRandomizeNetwork(); randomize.setRnd(new LinearCongruentialRandom(10)); randomize.randomize(network); double[] expected = {-0.48063016461488856, -0.6268874420756946, 3.2098992119169534E-4, -0.1914041699971798, 1.040596563646283, -0.485186340462527, -1.110171460956511, -1.0430309621862426, -0.13325874823843634, -0.18257850835630843, 0.228311697697274, 0.2916967306617774, -0.43452699284274987}; Assert.assertArrayEquals(expected,network.getWeights(), AIFH.DEFAULT_PRECISION); }
KMeans { public void initRandom(final List<BasicData> theObservations) { final int dimensions = findDimensions(theObservations); for (int i = 0; i < this.k; i++) { this.clusters.add(new Cluster(dimensions)); } for (final BasicData observation : theObservations) { final int clusterIndex = this.randomGeneration.nextInt(this.k); final Cluster cluster = this.clusters.get(clusterIndex); cluster.getObservations().add(observation); } for (final Cluster cluster : this.clusters) { if (cluster.getObservations().size() == 0) { boolean done = false; while (!done) { final int sourceIndex = this.randomGeneration.nextInt(this.k); final Cluster source = this.clusters.get(sourceIndex); if (source != cluster && source.getObservations().size() > 1) { final int sourceObservationIndex = this.randomGeneration.nextInt(source.getObservations().size()); final BasicData sourceObservation = source.getObservations().get(sourceObservationIndex); source.getObservations().remove(sourceObservationIndex); cluster.getObservations().add(sourceObservation); done = true; } } } } updateStep(); } KMeans(final int theK); void initRandom(final List<BasicData> theObservations); void initForgy(final List<BasicData> theObservations); Cluster findNearestCluster(final double[] observation); boolean iteration(); int iteration(final int maxIterations); GenerateRandom getRandomGeneration(); void setRandomGeneration(final GenerateRandom randomGeneration); CalculateDistance getDistanceMetric(); void setDistanceMetric(final CalculateDistance distanceMetric); int getK(); List<Cluster> getClusters(); }
@Test(expected = AIFHError.class) public void testTooManyClusters() { final KMeans kmeans = new KMeans(13); kmeans.initRandom(getDataSet()); }
KMeans { public boolean iteration() { if (this.clusters.size() == 0) { throw new AIFHError("Must call one of the init methods first."); } final boolean done = assignmentStep(); if (!done) { updateStep(); } return done; } KMeans(final int theK); void initRandom(final List<BasicData> theObservations); void initForgy(final List<BasicData> theObservations); Cluster findNearestCluster(final double[] observation); boolean iteration(); int iteration(final int maxIterations); GenerateRandom getRandomGeneration(); void setRandomGeneration(final GenerateRandom randomGeneration); CalculateDistance getDistanceMetric(); void setDistanceMetric(final CalculateDistance distanceMetric); int getK(); List<Cluster> getClusters(); }
@Test(expected = AIFHError.class) public void testEarlyIteration() { final KMeans kmeans = new KMeans(3); kmeans.iteration(); }
SvgSanitizer { public static String sanitize(String svg){ svg = removeXMLNS(svg); svg = removeDuplicateXmlnsXlink(svg); svg = removeNS1(svg); return svg; } static String sanitize(String svg); }
@Test void sanitize_withTwoXmlns_RemovesSuperfluousXmlns(){ String expectedSVG = "<svg height=\"1000\" width=\"1583\" xmlns:xlink=\"http: String inputSVG = "<svg xmlns=\"http: assertEquals(expectedSVG, SvgSanitizer.sanitize(inputSVG)); } @Test void sanitize_withTwoXmlnsInImageTagAndOneInSvgTag_RemovesSuperfluousXmlnsInImageTag() { String expectedSVG = "<svg id=\"SvgjsSvg1298\" xmlns:xlink=\"http: String inputSVG = "<svg id=\"SvgjsSvg1298\" xmlns:xlink=\"http: assertEquals(expectedSVG, SvgSanitizer.sanitize(inputSVG)); } @Test void sanitize_withSingleXmlns_DoesNotModifySVG(){ String expectedSVG = "<svg height=\"1000\" width=\"1583\" xmlns:xlink=\"http: String inputSVG = expectedSVG; assertEquals(expectedSVG, SvgSanitizer.sanitize(inputSVG)); } @Test void sanitize_withNS1_RemovesNS1(){ String expectedSVG = "<svg id=\"SvgjsSvg1106\" style=\"overflow: visible;\" width=\"1369\" height=\"1637\" xmlns=\"http: String inputSVG = "<svg id=\"SvgjsSvg1106\" style=\"overflow: visible;\" width=\"1369\" height=\"1637\" xmlns=\"http: assertEquals(expectedSVG, SvgSanitizer.sanitize(inputSVG)); } @Test void sanitize_withoutNS1_DoesNotModifySVG(){ String expectedSVG = "<svg id=\"SvgjsSvg1106\" style=\"overflow: visible;\" width=\"1369\" height=\"1637\" xmlns=\"http: String inputSVG = "<svg id=\"SvgjsSvg1106\" style=\"overflow: visible;\" width=\"1369\" height=\"1637\" xmlns=\"http: assertEquals(expectedSVG, SvgSanitizer.sanitize(inputSVG)); }
StepIdentifier { @JsonIgnore public URI getStepUriForRedirect() { return createUriForRedirect(RedirectType.STEP, null); } StepIdentifier(); StepIdentifier(final BuildIdentifier buildIdentifier, final String usecaseName, final String scenarioName, final String pageName, final int pageOccurrence, final int stepInPageOccurrence); StepIdentifier(final BuildIdentifier buildIdentifier, final String usecaseName, final String scenarioName, final String pageName, final int pageOccurrence, final int stepInPageOccurrence, final Set<String> labels); StepIdentifier(final ScenarioIdentifier scenarioIdentifier, final String pageName, final int pageOccurrence, final int stepInPageOccurrence); StepIdentifier(final ScenarioIdentifier scenarioIdentifier, final String pageName, final int pageOccurrence, final int stepInPageOccurrence, final Set<String> labels); static StepIdentifier withDifferentStepInPageOccurrence(final StepIdentifier stepIdentifier, final int stepInPageOccurrence); static StepIdentifier withDifferentIds(final StepIdentifier stepIdentifier, final int pageOccurrence, final int stepInPageOccurrence); static StepIdentifier forFallBackScenario(final StepIdentifier originalStepIdentifier, final String fallbackUsecaseName, final String fallbackScenarioName, final int pageOccurrence, final int stepInPageOccurrence); StepIdentifier withDifferentBuildIdentifier(final BuildIdentifier buildIdentifierBeforeAliasResolution); @JsonIgnore BuildIdentifier getBuildIdentifier(); @JsonIgnore ScenarioIdentifier getScenarioIdentifier(); @JsonIgnore void setScenarioIdentifier(final ScenarioIdentifier scenarioIdentifier); @XmlElement String getBranchName(); void setBranchName(final String branchName); @XmlElement String getBuildName(); void setBuildName(final String buildName); @XmlElement String getUsecaseName(); void setUsecaseName(final String usecaseName); @XmlElement String getScenarioName(); void setScenarioName(final String scenarioName); String getPageName(); void setPageName(final String pageName); int getPageOccurrence(); void setPageOccurrence(final int pageOccurrence); int getStepInPageOccurrence(); void setStepInPageOccurrence(final int stepInPageOccurrence); Set<String> getLabels(); void setLabels(final Set<String> labels); @JsonIgnore URI getScreenshotUriForRedirect(final String screenshotFileNameExtension); @JsonIgnore URI getStepUriForRedirect(); @Override String toString(); }
@Test public void redirectUrlForStepWithoutContextPath() { String contextPath = ContextPathHolder.INSTANCE.getContextPath(); ContextPathHolder.INSTANCE.setContextPath(""); try { assertEquals( "/rest/branch/bugfix-branch/build/build-2014-08-12/usecase/Find the answer/scenario/Actually find it/pageName/pageName1/pageOccurrence/0/stepInPageOccurrence/0", stepIdentifier.getStepUriForRedirect().getPath()); assertEquals("fallback=true", stepIdentifier.getStepUriForRedirect().getQuery()); } finally { ContextPathHolder.INSTANCE.setContextPath(contextPath); } } @Test public void redirectUrlForStep() { assertEquals( "/scenarioo/rest/branch/bugfix-branch/build/build-2014-08-12/usecase/Find the answer/scenario/Actually find it/pageName/pageName1/pageOccurrence/0/stepInPageOccurrence/0", stepIdentifier.getStepUriForRedirect().getPath()); assertEquals("fallback=true", stepIdentifier.getStepUriForRedirect().getQuery()); }
AvailableBuildsList { public synchronized List<BranchBuilds> getBranchBuildsList() { return branchBuildsList; } synchronized List<BranchBuilds> getBranchBuildsList(); synchronized BranchBuilds getBranchBuilds(final String branchName); synchronized void updateBuildsWithSuccessfullyImportedBuilds(final List<BranchBuilds> branchBuildsList, final Map<BuildIdentifier, BuildImportSummary> buildImportSummaries); synchronized void refreshAliases(); synchronized void addImportedBuild(final BuildImportSummary buildImportSummary); void removeBuild(final BuildIdentifier buildIdentifier); String resolveAliasBuildName(final String branchName, final String buildName); void logAvailableBuildsInformation(); }
@Test void testInitializedEmpty() { assertEquals(0, availableBuildsList.getBranchBuildsList().size(), "Expected initialized as empty list"); }
AvailableBuildsList { public synchronized void updateBuildsWithSuccessfullyImportedBuilds(final List<BranchBuilds> branchBuildsList, final Map<BuildIdentifier, BuildImportSummary> buildImportSummaries) { List<BranchBuilds> result = new ArrayList<BranchBuilds>(); for (BranchBuilds branchBuilds : branchBuildsList) { BranchBuilds resultBranchBuilds = new BranchBuilds(); resultBranchBuilds.setBranch(branchBuilds.getBranch()); List<BuildLink> resultBuilds = new ArrayList<BuildLink>(); resultBranchBuilds.setBuilds(resultBuilds); for (BuildLink buildLink : branchBuilds.getBuilds()) { BuildIdentifier buildIdentifier = new BuildIdentifier(branchBuilds.getBranch().getName(), buildLink .getBuild().getName()); BuildImportSummary summary = buildImportSummaries.get(buildIdentifier); if (summary != null && summary.getStatus().isSuccess()) { resultBuilds.add(buildLink); } } updateAliasesForRecentBuilds(resultBranchBuilds); BuildSorter.sort(resultBranchBuilds.getBuilds()); result.add(resultBranchBuilds); } updateBuilds(result); logAvailableBuildsInformation(); } synchronized List<BranchBuilds> getBranchBuildsList(); synchronized BranchBuilds getBranchBuilds(final String branchName); synchronized void updateBuildsWithSuccessfullyImportedBuilds(final List<BranchBuilds> branchBuildsList, final Map<BuildIdentifier, BuildImportSummary> buildImportSummaries); synchronized void refreshAliases(); synchronized void addImportedBuild(final BuildImportSummary buildImportSummary); void removeBuild(final BuildIdentifier buildIdentifier); String resolveAliasBuildName(final String branchName, final String buildName); void logAvailableBuildsInformation(); }
@Test void testUpdatingAvailableBuildsFromNoSuccessfullyImported() { List<BranchBuilds> branchBuilds = new ArrayList<>(Arrays.asList( createBranchBuilds("trunk", build5, build1, build6, build3, build7), createBranchBuilds("branch", build2, build4))); Map<BuildIdentifier, BuildImportSummary> buildImportSummaries = createBuildImportSummaries(branchBuilds); availableBuildsList.updateBuildsWithSuccessfullyImportedBuilds(branchBuilds, buildImportSummaries); assertNumberOfBuilds("trunk", 0); assertNumberOfBuilds("branch", 0); } @Test void testUpdatingAvailableBuildsFromSuccessfullyImported() { List<BranchBuilds> branchBuilds = new ArrayList<>(Arrays.asList( createBranchBuilds("trunk", build5, build1, build6, build3, build7), createBranchBuilds("branch", build2, build4))); Map<BuildIdentifier, BuildImportSummary> buildImportSummaries = createBuildImportSummaries(branchBuilds, "build1", "build2", "build3", "build4", "build5"); availableBuildsList.updateBuildsWithSuccessfullyImportedBuilds(branchBuilds, buildImportSummaries); assertNumberOfBuilds("trunk", 5); assertAliasContainedAtPosition("trunk", DEFAULT_ALIAS_FOR_LAST_SUCCESSFUL_BUILD, 0, build3.getBuild()); assertAliasContainedAtPosition("trunk", DEFAULT_ALIAS_FOR_MOST_RECENT_BUILD, 1, build5.getBuild()); assertBuildContainedAtPosition("trunk", 2, build5); assertBuildContainedAtPosition("trunk", 4, build1); assertNumberOfBuilds("branch", 4); assertAliasContainedAtPosition("branch", DEFAULT_ALIAS_FOR_LAST_SUCCESSFUL_BUILD, 0, build2.getBuild()); assertAliasContainedAtPosition("branch", DEFAULT_ALIAS_FOR_MOST_RECENT_BUILD, 1, build4.getBuild()); assertBuildContainedAtPosition("branch", 2, build4); assertBuildContainedAtPosition("branch", 3, build2); }
BuildByDateSorter { public static List<BuildImportSummary> sortBuildsByDateDescending(final Collection<BuildImportSummary> unsortedSummaries) { List<BuildImportSummary> summaries = new LinkedList<BuildImportSummary>(); summaries.addAll(unsortedSummaries); Collections.sort(summaries, new BuildImportSummaryDateDescendingComparator()); return summaries; } static List<BuildImportSummary> sortBuildsByDateDescending(final Collection<BuildImportSummary> unsortedSummaries); }
@Test void sortBuildsByDateDescending_givenTwoBuildsInAscendingOder_resultsInTwoBuildsInDescendingOrder() { List<BuildImportSummary> buildsAscending = new LinkedList<>(); buildsAscending.add(OLDER_BUILD); buildsAscending.add(NEWER_BUILD); List<BuildImportSummary> buildsByDateDescending = BuildByDateSorter.sortBuildsByDateDescending(buildsAscending); assertBuildDescriptionIsEqual(NEWER_BUILD, buildsByDateDescending.get(0)); assertBuildDescriptionIsEqual(OLDER_BUILD, buildsByDateDescending.get(1)); } @Test void sortBuildsByDateDescending_givenOneBuildWithoutDate_buildWithDateComesFirst() { List<BuildImportSummary> buildsAscending = new LinkedList<>(); buildsAscending.add(BUILD_WITHOUT_DATE); buildsAscending.add(NEWER_BUILD); List<BuildImportSummary> buildsByDateDescending = BuildByDateSorter.sortBuildsByDateDescending(buildsAscending); assertBuildDescriptionIsEqual(NEWER_BUILD, buildsByDateDescending.get(0)); assertBuildDescriptionIsEqual(BUILD_WITHOUT_DATE, buildsByDateDescending.get(1)); } @Test void sortBuildsByDateDescending_givenFourBuilds_theyAreSortedInDescendingOrder() { List<BuildImportSummary> buildsAscending = new LinkedList<>(); buildsAscending.add(BUILD_WITHOUT_DATE); buildsAscending.add(NEWER_BUILD); buildsAscending.add(MIDDLE_BUILD); buildsAscending.add(OLDER_BUILD); List<BuildImportSummary> buildsByDateDescending = BuildByDateSorter.sortBuildsByDateDescending(buildsAscending); assertBuildDescriptionIsEqual(NEWER_BUILD, buildsByDateDescending.get(0)); assertBuildDescriptionIsEqual(MIDDLE_BUILD, buildsByDateDescending.get(1)); assertBuildDescriptionIsEqual(OLDER_BUILD, buildsByDateDescending.get(2)); assertBuildDescriptionIsEqual(BUILD_WITHOUT_DATE, buildsByDateDescending.get(3)); }
BuildSorter implements Comparator<BuildLink> { public static void sort(final List<BuildLink> builds) { Collections.sort(builds, new BuildSorter()); } static void sort(final List<BuildLink> builds); @Override int compare(final BuildLink bl1, final BuildLink bl2); }
@Test void testSortingSomeBuilds() { BuildLink build1 = createBuildSuccess("build1", 1); BuildLink build2 = createBuildSuccess("build2", 2); BuildLink build3 = createBuildFailed("build3", 3); BuildLink aliasCurrent = createBuildAlias(Configuration.DEFAULT_ALIAS_FOR_LAST_SUCCESSFUL_BUILD, build2.getBuild()); BuildLink aliasLast = createBuildAlias(Configuration.DEFAULT_ALIAS_FOR_MOST_RECENT_BUILD, build3.getBuild()); List<BuildLink> buildsList = Arrays.asList(build1, build2, build3, aliasCurrent, aliasLast); BuildSorter.sort(buildsList); assertSame(aliasCurrent, buildsList.get(0), "default build alias 'current' expected as first element"); assertSame(aliasLast, buildsList.get(1), "build alias 'last' expected as second element"); assertSame(build3, buildsList.get(2), "build3 expected as first non-aliased build (builds sorted by dates decreasing)"); assertSame(build1, buildsList.get(4), "build1 expected as last non-aliased build (builds sorted by dates decreasing)"); }
UseCaseComparator extends AbstractStructureComparator<UseCase, String, UseCase> { public BuildDiffInfo compare() { final List<UseCase> baseUseCases = scenarioDocuReader.loadUsecases(parameters.getBaseBranchName(), parameters.getBaseBuildName()); final List<UseCase> comparisonUseCases = scenarioDocuReader.loadUsecases( parameters.getComparisonConfiguration().getComparisonBranchName(), parameters.getComparisonConfiguration().getComparisonBuildName()); final BuildDiffInfo buildDiffInfo = new BuildDiffInfo(parameters.getComparisonConfiguration().getName(), parameters.getComparisonConfiguration().getComparisonBranchName(), parameters.getComparisonConfiguration().getComparisonBuildName()); calculateDiffInfo(baseUseCases, comparisonUseCases, buildDiffInfo); buildDiffInfo.setStatus(ComparisonCalculationStatus.SUCCESS); LOGGER.info(getLogMessage(buildDiffInfo, "Build " + parameters.getBaseBranchName() + "/" + parameters.getBaseBuildName())); return buildDiffInfo; } UseCaseComparator(ComparisonParameters parameters); BuildDiffInfo compare(); }
@Test void testCompareBuildsEqual() { List<UseCase> baseUseCases = getUseCases(USE_CASE_NAME_1, USE_CASE_NAME_2, USE_CASE_NAME_3); List<UseCase> comparisonUseCases = getUseCases(USE_CASE_NAME_1, USE_CASE_NAME_2, USE_CASE_NAME_3); UseCaseDiffInfo useCaseDiffInfo = getUseCaseDiffInfo(0, 0, 0, 0); initMocks(baseUseCases, comparisonUseCases, useCaseDiffInfo); BuildDiffInfo buildDiffInfo = useCaseComparator.compare(); assertEquals(0, buildDiffInfo.getChangeRate(), 0.0); assertEquals(0, buildDiffInfo.getAdded()); assertEquals(0, buildDiffInfo.getChanged()); assertEquals(0, buildDiffInfo.getRemoved()); assertTrue(buildDiffInfo.getAddedElements().isEmpty()); assertTrue(buildDiffInfo.getRemovedElements().isEmpty()); } @Test void testCompareOneUseCaseAdded() { List<UseCase> baseUseCases = getUseCases(USE_CASE_NAME_1, USE_CASE_NAME_2, USE_CASE_NAME_3); List<UseCase> comparisonUseCases = getUseCases(USE_CASE_NAME_1, USE_CASE_NAME_2); UseCaseDiffInfo useCaseDiffInfo = getUseCaseDiffInfo(0, 0, 0, 0); initMocks(baseUseCases, comparisonUseCases, useCaseDiffInfo); BuildDiffInfo buildDiffInfo = useCaseComparator.compare(); double expectedChangeRate = 100.0 / 3.0; assertEquals(expectedChangeRate, buildDiffInfo.getChangeRate(), 0.0); assertEquals(1, buildDiffInfo.getAdded()); assertEquals(0, buildDiffInfo.getChanged()); assertEquals(0, buildDiffInfo.getRemoved()); assertEquals(USE_CASE_NAME_3, buildDiffInfo.getAddedElements().get(0)); assertTrue(buildDiffInfo.getRemovedElements().isEmpty()); } @Test void testCompareMultipleUseCasesAdded() { List<UseCase> baseUseCases = getUseCases(USE_CASE_NAME_1, USE_CASE_NAME_2, USE_CASE_NAME_3); List<UseCase> comparisonUseCases = getUseCases(USE_CASE_NAME_2); UseCaseDiffInfo useCaseDiffInfo = getUseCaseDiffInfo(0, 0, 0, 0); initMocks(baseUseCases, comparisonUseCases, useCaseDiffInfo); BuildDiffInfo buildDiffInfo = useCaseComparator.compare(); double expectedChangeRate = 200.0 / 3.0; assertEquals(expectedChangeRate, buildDiffInfo.getChangeRate(), 0.0); assertEquals(2, buildDiffInfo.getAdded()); assertEquals(0, buildDiffInfo.getChanged()); assertEquals(0, buildDiffInfo.getRemoved()); assertEquals(USE_CASE_NAME_1, buildDiffInfo.getAddedElements().get(0)); assertEquals(USE_CASE_NAME_3, buildDiffInfo.getAddedElements().get(1)); assertTrue(buildDiffInfo.getRemovedElements().isEmpty()); } @Test void testCompareUseCaseChangedTo50Percentage() { double changeRatePerUseCase = 50.0; List<UseCase> baseUseCases = getUseCases(USE_CASE_NAME_1, USE_CASE_NAME_2, USE_CASE_NAME_3); List<UseCase> comparisonUseCases = getUseCases(USE_CASE_NAME_1, USE_CASE_NAME_2, USE_CASE_NAME_3); UseCaseDiffInfo useCaseDiffInfo = getUseCaseDiffInfo(changeRatePerUseCase, 1, 1, 1); initMocks(baseUseCases, comparisonUseCases, useCaseDiffInfo); BuildDiffInfo buildDiffInfo = useCaseComparator.compare(); double expectedChangeRate = changeRatePerUseCase; assertEquals(expectedChangeRate, buildDiffInfo.getChangeRate(), 0.0); assertEquals(0, buildDiffInfo.getAdded()); assertEquals(3, buildDiffInfo.getChanged()); assertEquals(0, buildDiffInfo.getRemoved()); assertTrue(buildDiffInfo.getAddedElements().isEmpty()); assertTrue(buildDiffInfo.getRemovedElements().isEmpty()); } @Test void testCompareOneUseCaseRemoved() { List<UseCase> baseUseCases = getUseCases(USE_CASE_NAME_1); List<UseCase> comparisonUseCases = getUseCases(USE_CASE_NAME_1, USE_CASE_NAME_2); UseCase removedUseCase = comparisonUseCases.get(1); UseCaseDiffInfo useCaseDiffInfo = getUseCaseDiffInfo(0, 0, 0, 0); initMocks(baseUseCases, comparisonUseCases, useCaseDiffInfo); BuildDiffInfo buildDiffInfo = useCaseComparator.compare(); double expectedChangeRate = 100.0 / 2.0; assertEquals(expectedChangeRate, buildDiffInfo.getChangeRate(), 0.0); assertEquals(0, buildDiffInfo.getAdded()); assertEquals(0, buildDiffInfo.getChanged()); assertEquals(1, buildDiffInfo.getRemoved()); assertTrue(buildDiffInfo.getAddedElements().isEmpty()); assertEquals(removedUseCase, buildDiffInfo.getRemovedElements().get(0)); } @Test void testCompareMultipleUseCasesRemoved() { List<UseCase> baseUseCases = getUseCases(USE_CASE_NAME_2); List<UseCase> comparisonUseCases = getUseCases(USE_CASE_NAME_1, USE_CASE_NAME_2, USE_CASE_NAME_3); UseCase removedUseCase1 = comparisonUseCases.get(0); UseCase removedUseCase2 = comparisonUseCases.get(2); UseCaseDiffInfo useCaseDiffInfo = getUseCaseDiffInfo(0, 0, 0, 0); initMocks(baseUseCases, comparisonUseCases, useCaseDiffInfo); BuildDiffInfo buildDiffInfo = useCaseComparator.compare(); double expectedChangeRate = 200.0 / 3.0; assertEquals(expectedChangeRate, buildDiffInfo.getChangeRate(), 0.0); assertEquals(0, buildDiffInfo.getAdded()); assertEquals(0, buildDiffInfo.getChanged()); assertEquals(2, buildDiffInfo.getRemoved()); assertTrue(buildDiffInfo.getAddedElements().isEmpty()); assertEquals(removedUseCase1, buildDiffInfo.getRemovedElements().get(0)); assertEquals(removedUseCase2, buildDiffInfo.getRemovedElements().get(1)); } @Test void testCompareEmptyBaseUseCaseName() { List<UseCase> baseUseCases = getUseCases(USE_CASE_NAME_1, null); List<UseCase> comparisonUseCases = getUseCases(USE_CASE_NAME_1, USE_CASE_NAME_2, USE_CASE_NAME_3); UseCaseDiffInfo useCaseDiffInfo = getUseCaseDiffInfo(0, 0, 0, 0); initMocks(baseUseCases, comparisonUseCases, useCaseDiffInfo); assertThrows(RuntimeException.class, () -> useCaseComparator.compare()); }
StepComparator extends AbstractStructureComparator<StepLink, Integer, StepInfo> { public ScenarioDiffInfo compare(final String baseUseCaseName, final String baseScenarioName) { this.baseUseCaseName = baseUseCaseName; this.baseScenarioName = baseScenarioName; final List<Step> baseSteps = loadSteps(parameters.getBaseBranchName(), parameters.getBaseBuildName()); this.comparisonSteps = loadSteps(parameters.getComparisonConfiguration().getComparisonBranchName(), parameters.getComparisonConfiguration().getComparisonBuildName()); final List<StepLink> baseStepLinks = stepAndPagesAggregator.calculateStepLinks(baseSteps, baseUseCaseName, baseScenarioName); final List<StepLink> comparisonStepLinks = stepAndPagesAggregator.calculateStepLinks(comparisonSteps, baseUseCaseName, baseScenarioName); final ScenarioDiffInfo scenarioDiffInfo = new ScenarioDiffInfo(baseScenarioName); calculateDiffInfo(baseStepLinks, comparisonStepLinks, scenarioDiffInfo); LOGGER.info(getLogMessage(scenarioDiffInfo, "Scenario " + parameters.getBaseBranchName() + "/" + parameters.getBaseBuildName() + "/" + baseUseCaseName + "/" + baseScenarioName)); return scenarioDiffInfo; } StepComparator(ComparisonParameters parameters, ScreenshotComparator screenshotComparator); ScenarioDiffInfo compare(final String baseUseCaseName, final String baseScenarioName); }
@Test void buildsEqual() { List<Step> baseSteps = getSteps(PAGE_NAME_1, PAGE_NAME_1, PAGE_NAME_2); List<Step> comparisonSteps = getSteps(PAGE_NAME_1, PAGE_NAME_1, PAGE_NAME_2); initMocks(baseSteps, comparisonSteps, 0.0); ScenarioDiffInfo scenarioDiffInfo = stepComparator.compare(USE_CASE_NAME, SCENARIO_NAME); assertEquals(0, scenarioDiffInfo.getChangeRate(), 0.0); assertEquals(0, scenarioDiffInfo.getAdded()); assertEquals(0, scenarioDiffInfo.getChanged()); assertEquals(0, scenarioDiffInfo.getRemoved()); assertTrue(scenarioDiffInfo.getAddedElements().isEmpty()); assertTrue(scenarioDiffInfo.getRemovedElements().isEmpty()); } @Test void oneStepAdded() { List<Step> baseSteps = getSteps(PAGE_NAME_1, PAGE_NAME_1, PAGE_NAME_2); List<Step> comparisonSteps = getSteps(PAGE_NAME_1, PAGE_NAME_1); initMocks(baseSteps, comparisonSteps, 0.0); ScenarioDiffInfo scenarioDiffInfo = stepComparator.compare(USE_CASE_NAME, SCENARIO_NAME); double expectedChangeRate = 100.0 / 3.0; assertEquals(expectedChangeRate, scenarioDiffInfo.getChangeRate(), 0.0); assertEquals(1, scenarioDiffInfo.getAdded()); assertEquals(0, scenarioDiffInfo.getChanged()); assertEquals(0, scenarioDiffInfo.getRemoved()); assertEquals(new Integer(2), scenarioDiffInfo.getAddedElements().get(0)); assertTrue(scenarioDiffInfo.getRemovedElements().isEmpty()); } @Test void multipleStepsAdded() { List<Step> baseSteps = getSteps(PAGE_NAME_1, PAGE_NAME_1, PAGE_NAME_2); List<Step> comparisonSteps = getSteps(PAGE_NAME_1); initMocks(baseSteps, comparisonSteps, 0.0); ScenarioDiffInfo scenarioDiffInfo = stepComparator.compare(USE_CASE_NAME, SCENARIO_NAME); double expectedChangeRate = 200.0 / 3.0; assertEquals(expectedChangeRate, scenarioDiffInfo.getChangeRate(), 0.0); assertEquals(2, scenarioDiffInfo.getAdded()); assertEquals(0, scenarioDiffInfo.getChanged()); assertEquals(0, scenarioDiffInfo.getRemoved()); assertEquals(new Integer(1), scenarioDiffInfo.getAddedElements().get(0)); assertEquals(new Integer(2), scenarioDiffInfo.getAddedElements().get(1)); assertTrue(scenarioDiffInfo.getRemovedElements().isEmpty()); } @Test void stepChangedBy50Percent() { double changeRatePerStep = 50.0; List<Step> baseSteps = getSteps(PAGE_NAME_1, PAGE_NAME_1, PAGE_NAME_2); List<Step> comparisonSteps = getSteps(PAGE_NAME_1, PAGE_NAME_1, PAGE_NAME_2); initMocks(baseSteps, comparisonSteps, changeRatePerStep); ScenarioDiffInfo scenarioDiffInfo = stepComparator.compare(USE_CASE_NAME, SCENARIO_NAME); double expectedChangeRate = changeRatePerStep; assertEquals(expectedChangeRate, scenarioDiffInfo.getChangeRate(), 0.0); assertEquals(0, scenarioDiffInfo.getAdded()); assertEquals(3, scenarioDiffInfo.getChanged()); assertEquals(0, scenarioDiffInfo.getRemoved()); assertTrue(scenarioDiffInfo.getAddedElements().isEmpty()); assertTrue(scenarioDiffInfo.getRemovedElements().isEmpty()); } @Test void oneStepRemoved() { List<Step> baseSteps = getSteps(PAGE_NAME_1); List<Step> comparisonSteps = getSteps(PAGE_NAME_1, PAGE_NAME_1); initMocks(baseSteps, comparisonSteps, 0.0); ScenarioDiffInfo scenarioDiffInfo = stepComparator.compare(USE_CASE_NAME, SCENARIO_NAME); double expectedChangeRate = 100.0 / 2.0; assertEquals(expectedChangeRate, scenarioDiffInfo.getChangeRate(), 0.0); assertEquals(0, scenarioDiffInfo.getAdded()); assertEquals(0, scenarioDiffInfo.getChanged()); assertEquals(1, scenarioDiffInfo.getRemoved()); assertTrue(scenarioDiffInfo.getAddedElements().isEmpty()); assertEquals(PAGE_NAME_1, scenarioDiffInfo.getRemovedElements().get(0).getStepLink().getPageName()); } @Test void multipleStepsRemoved() { List<Step> baseSteps = getSteps(PAGE_NAME_1); List<Step> comparisonSteps = getSteps(PAGE_NAME_1, PAGE_NAME_1, PAGE_NAME_2); initMocks(baseSteps, comparisonSteps, 0.0); ScenarioDiffInfo scenarioDiffInfo = stepComparator.compare(USE_CASE_NAME, SCENARIO_NAME); double expectedChangeRate = 200.0 / 3.0; assertEquals(expectedChangeRate, scenarioDiffInfo.getChangeRate(), 0.0); assertEquals(0, scenarioDiffInfo.getAdded()); assertEquals(0, scenarioDiffInfo.getChanged()); assertEquals(2, scenarioDiffInfo.getRemoved()); assertTrue(scenarioDiffInfo.getAddedElements().isEmpty()); assertEquals(PAGE_NAME_1, scenarioDiffInfo.getRemovedElements().get(0).getStepLink().getPageName()); assertEquals(PAGE_NAME_2, scenarioDiffInfo.getRemovedElements().get(1).getStepLink().getPageName()); }
ScenarioComparator extends AbstractStructureComparator<Scenario, String, ScenarioSummary> { public UseCaseDiffInfo compare(final String baseUseCaseName) { this.baseUseCaseName = baseUseCaseName; final List<Scenario> baseScenarios = scenarioDocuReader.loadScenarios(parameters.getBaseBranchName(), parameters.getBaseBuildName(), baseUseCaseName); final List<Scenario> comparisonScenarios = scenarioDocuReader.loadScenarios( parameters.getComparisonConfiguration().getComparisonBranchName(), parameters.getComparisonConfiguration().getComparisonBuildName(), baseUseCaseName); final UseCaseDiffInfo useCaseDiffInfo = new UseCaseDiffInfo(baseUseCaseName); calculateDiffInfo(baseScenarios, comparisonScenarios, useCaseDiffInfo); LOGGER.info(getLogMessage(useCaseDiffInfo, "Use Case " + parameters.getBaseBranchName() + "/" + parameters.getBaseBuildName() + "/" + baseUseCaseName)); return useCaseDiffInfo; } ScenarioComparator(ComparisonParameters parameters); UseCaseDiffInfo compare(final String baseUseCaseName); }
@Test void testCompareBuildsEqual() { List<Scenario> baseScenarios = getScenarios(SCENARIO_NAME_1, SCENARIO_NAME_2, SCENARIO_NAME_3); List<Scenario> comparisonScenarios = getScenarios(SCENARIO_NAME_1, SCENARIO_NAME_2, SCENARIO_NAME_3); ScenarioDiffInfo scenarioDiffInfo = getScenarioDiffInfo(0, 0, 0, 0); initMocks(baseScenarios, comparisonScenarios, scenarioDiffInfo); UseCaseDiffInfo useCaseDiffInfo = scenarioComparator.compare(USE_CASE_NAME); assertEquals(0, useCaseDiffInfo.getChangeRate(), 0.0); assertEquals(0, useCaseDiffInfo.getAdded()); assertEquals(0, useCaseDiffInfo.getChanged()); assertEquals(0, useCaseDiffInfo.getRemoved()); assertTrue(useCaseDiffInfo.getAddedElements().isEmpty()); assertTrue(useCaseDiffInfo.getRemovedElements().isEmpty()); } @Test void testCompareOneScenarioAdded() { List<Scenario> baseScenarios = getScenarios(SCENARIO_NAME_1, SCENARIO_NAME_2, SCENARIO_NAME_3); List<Scenario> comparisonScenarios = getScenarios(SCENARIO_NAME_1, SCENARIO_NAME_2); ScenarioDiffInfo scenarioDiffInfo = getScenarioDiffInfo(0, 0, 0, 0); initMocks(baseScenarios, comparisonScenarios, scenarioDiffInfo); UseCaseDiffInfo useCaseDiffInfo = scenarioComparator.compare(USE_CASE_NAME); double expectedChangeRate = 100.0 / 3.0; assertEquals(expectedChangeRate, useCaseDiffInfo.getChangeRate(), 0.0); assertEquals(1, useCaseDiffInfo.getAdded()); assertEquals(0, useCaseDiffInfo.getChanged()); assertEquals(0, useCaseDiffInfo.getRemoved()); assertEquals(SCENARIO_NAME_3, useCaseDiffInfo.getAddedElements().get(0)); assertTrue(useCaseDiffInfo.getRemovedElements().isEmpty()); } @Test void testCompareMultipleScenariosAdded() { List<Scenario> baseScenarios = getScenarios(SCENARIO_NAME_1, SCENARIO_NAME_2, SCENARIO_NAME_3); List<Scenario> comparisonScenarios = getScenarios(SCENARIO_NAME_2); ScenarioDiffInfo scenarioDiffInfo = getScenarioDiffInfo(0, 0, 0, 0); initMocks(baseScenarios, comparisonScenarios, scenarioDiffInfo); UseCaseDiffInfo useCaseDiffInfo = scenarioComparator.compare(USE_CASE_NAME); double expectedChangeRate = 200.0 / 3.0; assertEquals(expectedChangeRate, useCaseDiffInfo.getChangeRate(), 0.0); assertEquals(2, useCaseDiffInfo.getAdded()); assertEquals(0, useCaseDiffInfo.getChanged()); assertEquals(0, useCaseDiffInfo.getRemoved()); assertEquals(SCENARIO_NAME_1, useCaseDiffInfo.getAddedElements().get(0)); assertEquals(SCENARIO_NAME_3, useCaseDiffInfo.getAddedElements().get(1)); assertTrue(useCaseDiffInfo.getRemovedElements().isEmpty()); } @Test void testCompareScenarioChangedTo50Percentage() { double changeRatePerScenario = 50.0; List<Scenario> baseScenarios = getScenarios(SCENARIO_NAME_1, SCENARIO_NAME_2, SCENARIO_NAME_3); List<Scenario> comparisonScenarios = getScenarios(SCENARIO_NAME_1, SCENARIO_NAME_2, SCENARIO_NAME_3); ScenarioDiffInfo scenarioDiffInfo = getScenarioDiffInfo(changeRatePerScenario, 1, 1, 1); initMocks(baseScenarios, comparisonScenarios, scenarioDiffInfo); UseCaseDiffInfo useCaseDiffInfo = scenarioComparator.compare(USE_CASE_NAME); double expectedChangeRate = changeRatePerScenario; assertEquals(expectedChangeRate, useCaseDiffInfo.getChangeRate(), 0.0); assertEquals(0, useCaseDiffInfo.getAdded()); assertEquals(3, useCaseDiffInfo.getChanged()); assertEquals(0, useCaseDiffInfo.getRemoved()); assertTrue(useCaseDiffInfo.getAddedElements().isEmpty()); assertTrue(useCaseDiffInfo.getRemovedElements().isEmpty()); } @Test void testCompareOneScenarioRemoved() { List<Scenario> baseScenarios = getScenarios(SCENARIO_NAME_1); List<Scenario> comparisonScenarios = getScenarios(SCENARIO_NAME_1, SCENARIO_NAME_2); Scenario removedScenario = comparisonScenarios.get(1); ScenarioDiffInfo scenarioDiffInfo = getScenarioDiffInfo(0, 0, 0, 0); initMocks(baseScenarios, comparisonScenarios, scenarioDiffInfo); UseCaseDiffInfo useCaseDiffInfo = scenarioComparator.compare(USE_CASE_NAME); double expectedChangeRate = 100.0 / 2.0; assertEquals(expectedChangeRate, useCaseDiffInfo.getChangeRate(), 0.0); assertEquals(0, useCaseDiffInfo.getAdded()); assertEquals(0, useCaseDiffInfo.getChanged()); assertEquals(1, useCaseDiffInfo.getRemoved()); assertTrue(useCaseDiffInfo.getAddedElements().isEmpty()); assertEquals(removedScenario.getName(), useCaseDiffInfo.getRemovedElements().get(0).getScenario().getName()); } @Test void testCompareMultipleScenariosRemoved() { List<Scenario> baseScenarios = getScenarios(SCENARIO_NAME_2); List<Scenario> comparisonScenarios = getScenarios(SCENARIO_NAME_1, SCENARIO_NAME_2, SCENARIO_NAME_3); Scenario removedScenario1 = comparisonScenarios.get(0); Scenario removedScenario2 = comparisonScenarios.get(2); ScenarioDiffInfo scenarioDiffInfo = getScenarioDiffInfo(0, 0, 0, 0); initMocks(baseScenarios, comparisonScenarios, scenarioDiffInfo); UseCaseDiffInfo useCaseDiffInfo = scenarioComparator.compare(USE_CASE_NAME); double expectedChangeRate = 200.0 / 3.0; assertEquals(expectedChangeRate, useCaseDiffInfo.getChangeRate(), 0.0); assertEquals(0, useCaseDiffInfo.getAdded()); assertEquals(0, useCaseDiffInfo.getChanged()); assertEquals(2, useCaseDiffInfo.getRemoved()); assertTrue(useCaseDiffInfo.getAddedElements().isEmpty()); assertEquals(removedScenario1.getName(), useCaseDiffInfo.getRemovedElements().get(0).getScenario().getName()); assertEquals(removedScenario2.getName(), useCaseDiffInfo.getRemovedElements().get(1).getScenario().getName()); } @Test void testCompareEmptyBaseScenarioName() { List<Scenario> baseScenarios = getScenarios(SCENARIO_NAME_1, null); List<Scenario> comparisonScenarios = getScenarios(SCENARIO_NAME_1, SCENARIO_NAME_2, SCENARIO_NAME_3); ScenarioDiffInfo scenarioDiffInfo = getScenarioDiffInfo(0, 0, 0, 0); initMocks(baseScenarios, comparisonScenarios, scenarioDiffInfo); assertThrows(RuntimeException.class, () -> scenarioComparator.compare(USE_CASE_NAME)); }
ComparisonExecutor { synchronized List<ComparisonConfiguration> getComparisonConfigurationsForBaseBranch(String baseBranchName) { List<ComparisonConfiguration> comparisonConfigurationsForBaseBranch = new LinkedList<>(); List<ComparisonConfiguration> comparisonConfigurations = configurationRepository.getConfiguration() .getComparisonConfigurations(); String resolvedBaseBranchName = aliasResolver.resolveBranchAlias(baseBranchName); for (ComparisonConfiguration comparisonConfiguration : comparisonConfigurations) { String resolvedConfigurationBaseBranchName = aliasResolver.resolveBranchAlias(comparisonConfiguration.getBaseBranchName()); if (resolvedBaseBranchName.equals(resolvedConfigurationBaseBranchName) || resolvedBaseBranchName.matches(resolvedConfigurationBaseBranchName)) { comparisonConfigurationsForBaseBranch.add(new ComparisonConfiguration(comparisonConfiguration, resolvedBaseBranchName)); } } return comparisonConfigurationsForBaseBranch; } ComparisonExecutor(AliasResolver aliasResolver); ComparisonExecutor(ThreadPoolExecutor executorService, AliasResolver aliasResolver); void scheduleAllConfiguredComparisonsForOneBuild(String baseBranchName, String baseBuildName); Future<BuildDiffInfo> scheduleComparison(String baseBranchName, String baseBuildName, String comparisonBranchName, String comparisonBuildName, String comparisonName); void executeAfterAllPendingComparisonsDone(Runnable task); boolean areAllComparisonCalculationsFinished(); }
@Test void testGetComparisonConfigurationsForBaseBranch1() { List<ComparisonConfiguration> result = comparisonExecutor .getComparisonConfigurationsForBaseBranch(BRANCH_NAME_1); assertEquals(NUMBER_OF_COMPARISONS_FOR_BRANCH_1, result.size()); assertThat(result.get(0)).isEqualToComparingFieldByField(comparisonConfiguration1); assertThat(result.get(1)).isEqualToComparingFieldByField(comparisonConfiguration2); assertThat(result.get(2)).isEqualToComparingFieldByField(comparisonConfiguration3); assertThat(result.get(3)).isEqualToComparingFieldByField(comparisonConfiguration4); assertThat(result.get(4)).isEqualToComparingFieldByField(comparisonConfiguration5MatchedForBranch1); } @Test void testGetComparisonConfigurationsForBaseBranch2() { List<ComparisonConfiguration> result = comparisonExecutor .getComparisonConfigurationsForBaseBranch(BRANCH_NAME_2); assertEquals(NUMBER_OF_COMPARISONS_FOR_BRANCH_2, result.size()); assertThat(result.get(0)).isEqualToComparingFieldByField(comparisonConfiguration5MatchedForBranch2); assertThat(result.get(1)).isEqualToComparingFieldByField(comparisonConfiguration6); }
ComparisonExecutor { ComparisonConfiguration resolveComparisonConfiguration( ComparisonConfiguration comparisonConfiguration, String baseBuildName) { String lastSuccessFulAlias = configurationRepository.getConfiguration().getAliasForLastSuccessfulBuild(); String mostRecentAlias = configurationRepository.getConfiguration().getAliasForMostRecentBuild(); String baseBranchName = this.aliasResolver.resolveBranchAlias(comparisonConfiguration.getBaseBranchName()); String comparisonBranchName = this.aliasResolver.resolveBranchAlias(comparisonConfiguration.getComparisonBranchName()); boolean isBuildsFromSameBranch = baseBranchName.equals(comparisonBranchName); boolean isComparisonToLastSuccessBuild = comparisonConfiguration.getComparisonBuildName().equals(lastSuccessFulAlias); boolean isComparisonToMostRecentBuild = comparisonConfiguration.getComparisonBuildName().equals(mostRecentAlias); boolean isComparisonToBuildAlias = isComparisonToLastSuccessBuild ||isComparisonToMostRecentBuild; BuildIdentifier comparisonBuildIdentifier; if (isBuildsFromSameBranch && isComparisonToBuildAlias) { comparisonBuildIdentifier = getPreviousBuildIdentifier( comparisonConfiguration, baseBuildName, isComparisonToLastSuccessBuild); } else { comparisonBuildIdentifier = this.aliasResolver.resolveBranchAndBuildAliases( comparisonConfiguration.getComparisonBranchName(), comparisonConfiguration.getComparisonBuildName()); } if (comparisonBuildIdentifier == null || baseBuildName.equals(comparisonBuildIdentifier.getBuildName())) { return null; } return getResolvedComparisonConfiguration(comparisonConfiguration, comparisonBuildIdentifier); } ComparisonExecutor(AliasResolver aliasResolver); ComparisonExecutor(ThreadPoolExecutor executorService, AliasResolver aliasResolver); void scheduleAllConfiguredComparisonsForOneBuild(String baseBranchName, String baseBuildName); Future<BuildDiffInfo> scheduleComparison(String baseBranchName, String baseBuildName, String comparisonBranchName, String comparisonBuildName, String comparisonName); void executeAfterAllPendingComparisonsDone(Runnable task); boolean areAllComparisonCalculationsFinished(); }
@Test void testResolveComparisonConfigurationLastSuccessfulSameBranch() { ComparisonConfiguration result = comparisonExecutor.resolveComparisonConfiguration( comparisonConfiguration1, BUILD_NAME_3); assertEquals(BRANCH_NAME_1, result.getBaseBranchName()); assertEquals(BRANCH_NAME_1, result.getComparisonBranchName()); assertEquals(BUILD_NAME_1, result.getComparisonBuildName()); } @Test void testResolveComparisonConfigurationMostRecentSameBranch() { ComparisonConfiguration result = comparisonExecutor.resolveComparisonConfiguration( comparisonConfiguration2, BUILD_NAME_3); assertEquals(BRANCH_NAME_1, result.getBaseBranchName()); assertEquals(BRANCH_NAME_1, result.getComparisonBranchName()); assertEquals(BUILD_NAME_2, result.getComparisonBuildName()); } @Test void testResolveComparisonConfigurationLastSuccessfulOtherBranch() { ComparisonConfiguration result = comparisonExecutor.resolveComparisonConfiguration( comparisonConfiguration3, BUILD_NAME_2); assertEquals(BRANCH_NAME_1, result.getBaseBranchName()); assertEquals(BRANCH_NAME_2, result.getComparisonBranchName()); assertEquals(BUILD_NAME_1, result.getComparisonBuildName()); } @Test void testResolveComparisonConfigurationSameBranchAndSameBuild() { ComparisonConfiguration result = comparisonExecutor.resolveComparisonConfiguration( comparisonConfiguration4, BUILD_NAME_1); assertNull(result); } @Test void testResolveComparisonConfigurationSameBranchAndBuildWithoutAlias() { ComparisonConfiguration config = getComparisonConfiguration(BRANCH_NAME_1, BRANCH_NAME_2, BUILD_NAME_2, COMPARISON_NAME); ComparisonConfiguration result = comparisonExecutor.resolveComparisonConfiguration( config, BUILD_NAME_1); assertEquals(BRANCH_NAME_1, result.getBaseBranchName()); assertEquals(BRANCH_NAME_2, result.getComparisonBranchName()); assertEquals(BUILD_NAME_2, result.getComparisonBuildName()); } @Test void testResolveComparisonConfigurationOtherBranchAndBuildWithoutAlias() { ComparisonConfiguration result = comparisonExecutor.resolveComparisonConfiguration( comparisonConfiguration6, BUILD_NAME_1); assertEquals(BRANCH_NAME_2, result.getBaseBranchName()); assertEquals(BRANCH_NAME_2, result.getComparisonBranchName()); assertEquals(BUILD_NAME_3, result.getComparisonBuildName()); }
ComparisonExecutor { public boolean areAllComparisonCalculationsFinished() { return asyncComparisonExecutor.getActiveCount() == 0; } ComparisonExecutor(AliasResolver aliasResolver); ComparisonExecutor(ThreadPoolExecutor executorService, AliasResolver aliasResolver); void scheduleAllConfiguredComparisonsForOneBuild(String baseBranchName, String baseBuildName); Future<BuildDiffInfo> scheduleComparison(String baseBranchName, String baseBuildName, String comparisonBranchName, String comparisonBuildName, String comparisonName); void executeAfterAllPendingComparisonsDone(Runnable task); boolean areAllComparisonCalculationsFinished(); }
@Test void testAreAllComparisonCalculationsFinishedWithNoRunningThreadsReturnsTrue() { when(threadPoolExecutor.getActiveCount()).thenReturn(0); assertTrue(comparisonExecutor.areAllComparisonCalculationsFinished()); } @Test void testAreAllComparisonCalculationsFinishedWithRunningThreadsReturnsFalse() { when(threadPoolExecutor.getActiveCount()).thenReturn(1); assertFalse(comparisonExecutor.areAllComparisonCalculationsFinished()); }
PageNameSanitizer { public static void sanitizePageName(final Step step) { if (step == null || step.getPage() == null) { return; } step.getPage().setName(sanitize(step.getPage().getName())); } static void sanitizePageNames(final List<Step> steps); static void sanitizePageName(final Step step); }
@Test void givenStepWithIllegalPageName_sanitizingPageNames_replacesIllegalCharacters() { Step step = getStepWithIllegalPageName(); PageNameSanitizer.sanitizePageName(step); assertEquals(SANITIZED, step.getPage().getName()); }
PageNameSanitizer { public static void sanitizePageNames(final List<Step> steps) { if (steps == null) { return; } for (Step step : steps) { sanitizePageName(step); } } static void sanitizePageNames(final List<Step> steps); static void sanitizePageName(final Step step); }
@Test void givenStepListWithIllegalPageNames_sanitizingPageNames_replacesIllegalCharacters() { List<Step> steps = getStepsWithIllegalPageName(); PageNameSanitizer.sanitizePageNames(steps); assertEquals(SANITIZED, steps.get(0).getPage().getName()); assertEquals(SANITIZED, steps.get(1).getPage().getName()); }
Configuration { @JsonIgnore public Color getDiffImageAwtColor() { int rgba = Long.decode(diffImageColor).intValue(); return new Color(rgba, true); } String getDefaultBranchName(); void setDefaultBranchName(final String defaultBranchName); String getDefaultBuildName(); void setDefaultBuildName(final String defaultBuildName); String getAliasForMostRecentBuild(); void setAliasForMostRecentBuild(final String aliasForMostRecentBuild); String getAliasForLastSuccessfulBuild(); void setAliasForLastSuccessfulBuild(final String aliasForLastSuccessfulBuild); String getBuildStatusForSuccessfulBuilds(); void setBuildStatusForSuccessfulBuilds(final String buildStatusForSuccessfulBuilds); String getScenarioPropertiesInOverview(); void setScenarioPropertiesInOverview(final String scenarioPropertiesInOverview); String getElasticSearchEndpoint(); void setElasticSearchEndpoint(String elasticSearchEndpoint); String getElasticSearchClusterName(); void setElasticSearchClusterName(String elasticSearchClusterName); String getApplicationName(); void setApplicationName(final String applicationName); String getApplicationInformation(); void setApplicationInformation(final String applicationInformation); String getBranchSelectionListOrder(); void setBranchSelectionListOrder(String branchSelectionListOrder); Map<String, String> getBuildstates(); void setBuildstates(final Map<String, String> buildstates); boolean isExpandPagesInScenarioOverview(); void setExpandPagesInScenarioOverview(final boolean expandPagesInScenarioOverview); List<BranchAlias> getBranchAliases(); void setBranchAliases(final List<BranchAlias> buildAliases); List<ComparisonConfiguration> getComparisonConfigurations(); void setComparisonConfigurations(final List<ComparisonConfiguration> comparisonConfigurations); Map<String, LabelConfiguration> getLabelConfigurations(); void setLabelConfigurations(final Map<String, LabelConfiguration> labelConfigurations); List<CustomObjectTab> getCustomObjectTabs(); void setCustomObjectTabs(final List<CustomObjectTab> customObjectTabs); boolean isCreateLastSuccessfulScenarioBuild(); void setCreateLastSuccessfulScenarioBuild(final boolean createLastSuccessfulScenarioBuild); String getDiffImageColor(); void setDiffImageColor(String color); @JsonIgnore Color getDiffImageAwtColor(); @JsonIgnore void setDiffImageAwtColor(Color diffColor); static final String DEFAULT_ALIAS_FOR_MOST_RECENT_BUILD; static final String DEFAULT_ALIAS_FOR_LAST_SUCCESSFUL_BUILD; }
@Test void testDefaultDiffImageColor() { Color actual = configuration.getDiffImageAwtColor(); assertThat(actual).isEqualTo(DEFAULT_DIFF_COLOR); }
ScenarioPageSteps { public int getTotalNumberOfStepsInPageOccurrence(final String pageName, final int pageOccurrence) { PageSteps pageWithSteps = getOccurrence(pageName, pageOccurrence); if (pageWithSteps == null) { return 0; } return pageWithSteps.getSteps().size(); } Scenario getScenario(); void setScenario(final Scenario scenario); ScenarioStatistics getScenarioStatistics(); UseCase getUseCase(); void setUseCase(final UseCase useCase); List<PageSteps> getPagesAndSteps(); void setPagesAndSteps(final List<PageSteps> pagesAndSteps); int getTotalNumberOfStepsInScenario(); StepStatistics getStepStatistics(final String pageName, final int pageOccurrence); int getTotalNumberOfStepsInPageOccurrence(final String pageName, final int pageOccurrence); StepDescription getStepDescription(final String pageName, final int pageOccurrence, final int stepInPageOccurrence); }
@Test void getTotalNumberOfStepsInPageOccurrence() { givenScenarioPagesAndSteps(); whenGettingTotalStepsForPage1SecondOccurrence(); expectTotalNumberOfStepsEquals(4); }
ScenarioPageSteps { public StepStatistics getStepStatistics(final String pageName, final int pageOccurrence) { StepStatistics statistics = new StepStatistics(); statistics.setTotalNumberOfStepsInScenario(getTotalNumberOfStepsInScenario()); statistics .setTotalNumberOfStepsInPageOccurrence(getTotalNumberOfStepsInPageOccurrence(pageName, pageOccurrence)); statistics.setTotalNumberOfPagesInScenario(getTotalNumberOfPagesInScenario()); return statistics; } Scenario getScenario(); void setScenario(final Scenario scenario); ScenarioStatistics getScenarioStatistics(); UseCase getUseCase(); void setUseCase(final UseCase useCase); List<PageSteps> getPagesAndSteps(); void setPagesAndSteps(final List<PageSteps> pagesAndSteps); int getTotalNumberOfStepsInScenario(); StepStatistics getStepStatistics(final String pageName, final int pageOccurrence); int getTotalNumberOfStepsInPageOccurrence(final String pageName, final int pageOccurrence); StepDescription getStepDescription(final String pageName, final int pageOccurrence, final int stepInPageOccurrence); }
@Test void getStepStatistics() { givenScenarioPagesAndSteps(); whenGettingPageStatisticsForPage1SecondOccurrence(); expectTotalNumberOfStepsInStatisticsEquals(7); expectTotalNumberOfStepsInPageOccurrenceInStatisticsEquals(4); expectTotalNumberOfPagesInScenarioInStatisticsEquals(3); }
LongObjectNamesResolver { public synchronized String resolveObjectFileName(final String fullLengthName) { if (fullLengthName.length() > 100) { return resolveLongName(fullLengthName); } else { return fullLengthName; } } synchronized String resolveObjectFileName(final String fullLengthName); }
@Test void testSmallNamesJustPass() { String shortName = "aShortName"; String resolvedFileName = resolver.resolveObjectFileName(shortName); assertEquals(shortName, resolvedFileName); } @Test void testLongNameIsShortened() { String longObjectName = "veryVeryVeryLongNameThatIsLongerThan100CharactersIsExpectedToBeShortenedByLongObjectNamesResolverSuchThatFileNamesDoNotBecomeTooLong"; String resolvedFileName = resolver.resolveObjectFileName(longObjectName); assertEquals( "veryVeryVeryLongNameThatIsLongerThan100CharactersIsExpectedToBeShortenedByLongObjectNamesResolverSuc-0", resolvedFileName, "Expected shortened name with suffix of collision index (0 for no collision yet)"); } @Test void testLongNamesResolvedCorrectly() { String longObjectName1 = "veryVeryVeryLongNameThatIsLongerThan100CharactersIsExpectedToBeShortenedByLongObjectNamesResolverSuchThatFileNamesDoNotBecomeTooLongOne"; String longObjectName2 = "veryVeryVeryLongNameThatIsLongerThan100CharactersIsExpectedToBeShortenedByLongObjectNamesResolverSuchThatFileNamesDoNotBecomeTooLongTwo"; String resolvedFileName1_firstCall = resolver.resolveObjectFileName(longObjectName1); String resolvedFileName2_firstCall = resolver.resolveObjectFileName(longObjectName2); String resolvedFileName1_secondCall = resolver.resolveObjectFileName(longObjectName1); String resolvedFileName2_secondCall = resolver.resolveObjectFileName(longObjectName2); assertEquals( "veryVeryVeryLongNameThatIsLongerThan100CharactersIsExpectedToBeShortenedByLongObjectNamesResolverSuc-0", resolvedFileName1_firstCall, "Expected shortened name with suffix of collision index (0 for no collision yet)"); assertEquals( "veryVeryVeryLongNameThatIsLongerThan100CharactersIsExpectedToBeShortenedByLongObjectNamesResolverSuc-1", resolvedFileName2_firstCall, "Expected shortened name with suffix of collision index (1 for first collision)"); assertEquals( resolvedFileName1_firstCall, resolvedFileName1_secondCall, "Expected same shortened name for calling resolver twice for same long name."); assertEquals( resolvedFileName2_firstCall, resolvedFileName2_secondCall, "Expected same shortened name for calling resolver twice for same long name."); }
ZipFileExtractor { public static void extractFile(final File zipFileToExtract, final File targetDir) throws ZipFileExtractionException { ZipFile zipFile = getZipFile(zipFileToExtract); if (targetDir.exists()) { try { FileUtils.deleteDirectory(targetDir); } catch (IOException e) { throw new ZipFileExtractionException("Could not delete target directory.", e); } } try { Enumeration<? extends ZipEntry> entries = zipFile.entries(); while (entries.hasMoreElements()) { ZipEntry entry = entries.nextElement(); File entryDestination = new File(targetDir, entry.getName()); if (entry.isDirectory()) { entryDestination.mkdirs(); } else { entryDestination.getParentFile().mkdirs(); InputStream in = zipFile.getInputStream(entry); OutputStream out = new FileOutputStream(entryDestination); IOUtils.copy(in, out); IOUtils.closeQuietly(in); out.close(); } } } catch (IOException e) { throw new ZipFileExtractionException("IO Error while extracting ZIP file.", e); } finally { IOUtils.closeQuietly(zipFile); } } static void extractFile(final File zipFileToExtract, final File targetDir); }
@Test void extractFile_withFileThatExists_successful() throws IOException, ZipFileExtractionException { File extractedFolder = new File(targetFolder, "aFolder"); FileUtils.deleteDirectory(extractedFolder); assertFalse(extractedFolder.exists()); ZipFileExtractor.extractFile(zipFile, targetFolder); assertAllFoldersAndFilesAreExtracted(extractedFolder); assertZipFileStillExists(zipFile); } @Test void extractFile_withFileThatDoesNotExists_throwsException() { File zipFile = new File(currentFolder, "InexistentFile.zip"); final ZipFileExtractionException thrown = assertThrows(ZipFileExtractionException.class, () -> ZipFileExtractor.extractFile(zipFile, targetFolder)); assertTrue(thrown.getMessage().startsWith("Zip file does not exist ")); } @Test void extractFile_andTargetFolderExistsWithExistingFile_successfulAndExistingFilesAreRemoved() throws IOException, ZipFileExtractionException { File extractedFolder = new File(targetFolder, "aFolder"); File existingFileInTargetFolder = new File(extractedFolder, "existingFile.txt"); givenTargetFolderWithExistingFile(extractedFolder, existingFileInTargetFolder); ZipFileExtractor.extractFile(zipFile, targetFolder); assertAllFoldersAndFilesAreExtracted(extractedFolder); assertZipFileStillExists(zipFile); assertFalse(existingFileInTargetFolder.exists()); }
NumberFormatter { public static final String formatMinimumThreeDigits(long number) { if(number < 0) { throw new RuntimeException("Encountered a negative number, which must be a bug: " + number); } return NumberFormatter.createNumberFormatWithMinimumIntegerDigits(3).format(number); } static final String formatMinimumThreeDigits(long number); }
@Test void formatMinimumThreeDigits_positiveNumbersAndZero_returnsFormattedNumber() { assertEquals("000", NumberFormatter.formatMinimumThreeDigits(0)); assertEquals("001", NumberFormatter.formatMinimumThreeDigits(1)); assertEquals("999", NumberFormatter.formatMinimumThreeDigits(999)); assertEquals("1000", NumberFormatter.formatMinimumThreeDigits(1000)); assertEquals("9223372036854775807", NumberFormatter.formatMinimumThreeDigits(Long.MAX_VALUE)); }
ScenariooDataPathLogic { String getDataPath(final ServletContext servletContext) { String configSource = "servlet context"; String configurationDirectory = servletContext.getInitParameter( "scenariooDataDirectory"); if (StringUtils.isBlank(configurationDirectory)) { configSource = "SCENARIOO_DATA environment variable or scenarioo.data application property"; configurationDirectory = systemEnvironment.getScenariooDataDirectory(); } if (StringUtils.isBlank(configurationDirectory)) { configSource = "default scenarioo data directory"; configurationDirectory = new File(systemEnvironment.getUserHome(), USER_HOME_BASE_DIRECTORY).getAbsolutePath(); } LOGGER.info(" Taking documentation data path from " + configSource + ": " + configurationDirectory); return configurationDirectory; } ScenariooDataPathLogic(final SystemEnvironment systemEnvironment); }
@Test void getDocumentationPath_GivenServletConfigAndEnvVariable_ChosesServletContextFirst() { when(servletContext.getInitParameter("scenariooDataDirectory")).thenReturn("tmp/test"); when(systemEnvironment.getScenariooDataDirectory()).thenReturn("tmp/itShouldNotBeMe"); String actual = logic.getDataPath(servletContext); assertEquals("tmp/test", actual); } @Test void getDocumentationPath_WhenServletContextParamIsNotPresent_ChosesEnvironmentVariable() { when(servletContext.getInitParameter("scenariooDataDirectory")).thenReturn(null); when(systemEnvironment.getScenariooDataDirectory()).thenReturn("tmp/test"); String actual = logic.getDataPath(servletContext); assertEquals("tmp/test", actual); } @Test void getDocumentationPath_WhenNoExternalConfigurationIsGiven_DefaultsToScenariooHomeFolder() { when(servletContext.getInitParameter("scenariooDataDirectory")).thenReturn(null); when(systemEnvironment.getScenariooDataDirectory()).thenReturn(null); when(systemEnvironment.getUserHome()).thenReturn("/home/someuser"); String expectedPath = new File("/home/someuser/.scenarioo").getAbsolutePath(); String actual = logic.getDataPath(servletContext); assertEquals(expectedPath, actual); }
IdGenerator { public static String generateRandomId() { UUID uuid = UUID.randomUUID(); return generateIdUsingHash(uuid.toString()); } static String generateRandomId(); static String generateIdUsingHash(final String value); }
@Test void randomIdHasLength8() { assertEquals(8, IdGenerator.generateRandomId().length()); } @Test void randomValuesAreAlwaysDifferent() { String first = IdGenerator.generateRandomId(); String second = IdGenerator.generateRandomId(); assertNotEquals(first, second); }
IdGenerator { public static String generateIdUsingHash(final String value) { MessageDigest converter; try { converter = MessageDigest.getInstance("SHA1"); String id = new String(Hex.encodeHex(converter.digest(value.getBytes()))); return id.substring(0, 8); } catch (final NoSuchAlgorithmException e) { LOGGER.info("Can't generate SHA1 hash code", e); throw new RuntimeException("Can't generate SHA1 hash code", e); } } static String generateRandomId(); static String generateIdUsingHash(final String value); }
@Test void allHashesAreOfLength8() { assertEquals(8, IdGenerator.generateIdUsingHash("").length()); assertEquals(8, IdGenerator.generateIdUsingHash("hello").length()); assertEquals(8, IdGenerator.generateIdUsingHash("hello world").length()); } @Test void hashOfNullString_throwsException() { assertThrows(NullPointerException.class, () -> IdGenerator.generateIdUsingHash(null)); } @Test void hashOfEmptyString() { assertEquals("da39a3ee", IdGenerator.generateIdUsingHash("")); } @Test void hashOfNonEmptyString() { assertEquals("3e3de94a", IdGenerator.generateIdUsingHash("Scenarioo")); }
SketcherDao { public void persistIssue(final String branchName, final Issue issue) { final File destinationFile = getIssueFile(branchName, issue.getIssueId()); createParentDirectoryIfNeeded(destinationFile); ScenarioDocuXMLFileUtil.marshal(issue, destinationFile); } SketcherDao(); File getRootDirectory(); File getBranchDirectory(final String branchName); File getIssueDirectory(final String branchName, final String issueId); File getIssueFile(final String branchName, final String issueId); List<File> getIssueFiles(final String branchName); File getScenarioSketchDirectory(final String branchName, final String issueId, final String scenarioSketchId); File getScenarioSketchFile(final String branchName, final String issueId, final String scenarioSketchId); List<File> getScenarioSketchFiles(final String branchName, final String issueId); File getStepSketchDirectory(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); File getStepSketchXmlFile(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); File getStepSketchXmlFile(final String branchName, final String issueId, final String scenarioSketchId, final StepSketch stepSketch); File getStepSketchSvgFile(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); File getStepSketchImageFile(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId, final String imageFilename); List<File> getStepSketchFiles(final String branchName, final String issueId, final String scenarioSketchId); void persistIssue(final String branchName, final Issue issue); void persistScenarioSketch(final String branchName, final String issueId, final ScenarioSketch scenarioSketch); void persistStepSketch(final String branchName, final String issueId, final String scenarioSketchId, final StepSketch stepSketch); void persistSketchAsSvgAndPng(final String branchName, final String issueId, final String scenarioSketchId, final StepSketch stepSketch); void copyOriginalScreenshot(final File originalScreenshot, final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); List<Issue> loadIssues(final String branchName); Issue loadIssue(final String branchName, final String issueId); List<ScenarioSketch> loadScenarioSketches(final String branchName, final String issueId); ScenarioSketch loadScenarioSketch(final String branchName, final String issueId, final String scenarioSketchId); List<StepSketch> loadStepSketches(final String branchName, final String issueId, final String scenarioSketchId); StepSketch loadStepSketch(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); static final String SKETCHER_DIRECTORY; }
@Test void persistIssue() { givenIssueDirectoryDoesNotExist(); sketcherDao.persistIssue(BRANCH_NAME, createIssue(ISSUE_ID)); expectIssueDirectoryExists(); expectIssuePersisted(); }
SketcherDao { public void persistStepSketch(final String branchName, final String issueId, final String scenarioSketchId, final StepSketch stepSketch) { final File stepSketchXmlFile = getStepSketchXmlFile(branchName, issueId, scenarioSketchId, stepSketch); createParentDirectoryIfNeeded(stepSketchXmlFile); ScenarioDocuXMLFileUtil.marshal(stepSketch, stepSketchXmlFile); } SketcherDao(); File getRootDirectory(); File getBranchDirectory(final String branchName); File getIssueDirectory(final String branchName, final String issueId); File getIssueFile(final String branchName, final String issueId); List<File> getIssueFiles(final String branchName); File getScenarioSketchDirectory(final String branchName, final String issueId, final String scenarioSketchId); File getScenarioSketchFile(final String branchName, final String issueId, final String scenarioSketchId); List<File> getScenarioSketchFiles(final String branchName, final String issueId); File getStepSketchDirectory(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); File getStepSketchXmlFile(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); File getStepSketchXmlFile(final String branchName, final String issueId, final String scenarioSketchId, final StepSketch stepSketch); File getStepSketchSvgFile(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); File getStepSketchImageFile(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId, final String imageFilename); List<File> getStepSketchFiles(final String branchName, final String issueId, final String scenarioSketchId); void persistIssue(final String branchName, final Issue issue); void persistScenarioSketch(final String branchName, final String issueId, final ScenarioSketch scenarioSketch); void persistStepSketch(final String branchName, final String issueId, final String scenarioSketchId, final StepSketch stepSketch); void persistSketchAsSvgAndPng(final String branchName, final String issueId, final String scenarioSketchId, final StepSketch stepSketch); void copyOriginalScreenshot(final File originalScreenshot, final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); List<Issue> loadIssues(final String branchName); Issue loadIssue(final String branchName, final String issueId); List<ScenarioSketch> loadScenarioSketches(final String branchName, final String issueId); ScenarioSketch loadScenarioSketch(final String branchName, final String issueId, final String scenarioSketchId); List<StepSketch> loadStepSketches(final String branchName, final String issueId, final String scenarioSketchId); StepSketch loadStepSketch(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); static final String SKETCHER_DIRECTORY; }
@Test void persistStepSketch() { givenIssueDirectoryDoesNotExist(); sketcherDao.persistStepSketch(BRANCH_NAME, ISSUE_ID, SCENARIO_SKETCH_ID, STEP_SKETCH); expectStepSketchDirectoryCreated(); expectStepSketchPersisted(); }
SketcherDao { public void persistSketchAsSvgAndPng(final String branchName, final String issueId, final String scenarioSketchId, final StepSketch stepSketch) { storeSvgFile(branchName, issueId, scenarioSketchId, stepSketch); storePngFile(branchName, issueId, scenarioSketchId, stepSketch.getStepSketchId(), stepSketch.getSvgXmlString()); } SketcherDao(); File getRootDirectory(); File getBranchDirectory(final String branchName); File getIssueDirectory(final String branchName, final String issueId); File getIssueFile(final String branchName, final String issueId); List<File> getIssueFiles(final String branchName); File getScenarioSketchDirectory(final String branchName, final String issueId, final String scenarioSketchId); File getScenarioSketchFile(final String branchName, final String issueId, final String scenarioSketchId); List<File> getScenarioSketchFiles(final String branchName, final String issueId); File getStepSketchDirectory(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); File getStepSketchXmlFile(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); File getStepSketchXmlFile(final String branchName, final String issueId, final String scenarioSketchId, final StepSketch stepSketch); File getStepSketchSvgFile(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); File getStepSketchImageFile(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId, final String imageFilename); List<File> getStepSketchFiles(final String branchName, final String issueId, final String scenarioSketchId); void persistIssue(final String branchName, final Issue issue); void persistScenarioSketch(final String branchName, final String issueId, final ScenarioSketch scenarioSketch); void persistStepSketch(final String branchName, final String issueId, final String scenarioSketchId, final StepSketch stepSketch); void persistSketchAsSvgAndPng(final String branchName, final String issueId, final String scenarioSketchId, final StepSketch stepSketch); void copyOriginalScreenshot(final File originalScreenshot, final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); List<Issue> loadIssues(final String branchName); Issue loadIssue(final String branchName, final String issueId); List<ScenarioSketch> loadScenarioSketches(final String branchName, final String issueId); ScenarioSketch loadScenarioSketch(final String branchName, final String issueId, final String scenarioSketchId); List<StepSketch> loadStepSketches(final String branchName, final String issueId, final String scenarioSketchId); StepSketch loadStepSketch(final String branchName, final String issueId, final String scenarioSketchId, final String stepSketchId); static final String SKETCHER_DIRECTORY; }
@Test void persistSketchAsSvgAndPng() { givenIssueDirectoryDoesNotExist(); sketcherDao.persistSketchAsSvgAndPng(BRANCH_NAME, ISSUE_ID, SCENARIO_SKETCH_ID, STEP_SKETCH); expectStepSketchDirectoryCreated(); expectSketchAsSvgPersisted(); expectSketchAsPngPersisted(); }
FileSystemOperationsDao { public void deleteBuild(final BuildIdentifier buildIdentifier) { File buildFolder = getBuildFolder( buildIdentifier); if (!buildFolder.exists()) { LOGGER.debug("Build folder " + buildFolder.getAbsolutePath() + " does not exist, therefore it can't be deleted."); return; } try { FileUtils.deleteDirectory(buildFolder); LOGGER.info("Deleted build folder " + buildFolder.getAbsolutePath()); } catch (IOException e) { LOGGER.error("Can't delete build " + buildIdentifier, e); } } FileSystemOperationsDao(); void deleteBuild(final BuildIdentifier buildIdentifier); void createBuildFolderIfItDoesNotExist(final BuildIdentifier buildIdentifier); boolean buildFolderExists(final BuildIdentifier buildIdentifier); }
@Test void deleteBuild_deletesTheEntireBuildFolderWithAllSubfoldersAndFiles() { givenBuildFolderContainingSubfoldersAndFiles(); fileSystemOperationsDao.deleteBuild(buildIdentifier); expectBuildFolderIsDeleted(); expectBranchFolderStillExists(); }
FileSystemOperationsDao { public void createBuildFolderIfItDoesNotExist(final BuildIdentifier buildIdentifier) { File buildFolder = getBuildFolder(buildIdentifier); if (buildFolder.exists()) { LOGGER.debug("Build folder " + buildFolder.getAbsolutePath() + " already exists."); return; } buildFolder.mkdirs(); if (buildFolder.exists()) { LOGGER.info("Created build folder " + buildFolder.getAbsolutePath()); } else { LOGGER.error("Could not create build folder " + buildFolder.getAbsolutePath()); } } FileSystemOperationsDao(); void deleteBuild(final BuildIdentifier buildIdentifier); void createBuildFolderIfItDoesNotExist(final BuildIdentifier buildIdentifier); boolean buildFolderExists(final BuildIdentifier buildIdentifier); }
@Test void createBuildFolderIfItDoesNotExist_createsTheFolderBecauseIfItDoesNotExist() { givenBuildFolderDoesNotExist(); fileSystemOperationsDao.createBuildFolderIfItDoesNotExist(buildIdentifier); expectBuildFolderExists(); }
DiffViewerDao { public BuildDiffInfo loadBuildDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName) { final File file = diffFiles.getBuildFile(baseBranchName, baseBuildName, comparisonName); return ScenarioDocuXMLFileUtil.unmarshal(BuildDiffInfo.class, file); } List<BuildDiffInfo> loadAllBuildDiffInfos(); List<BuildDiffInfo> loadBuildDiffInfos(final String baseBranchName, final String baseBuildName); BuildDiffInfo loadBuildDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName); List<UseCaseDiffInfo> loadUseCaseDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName); UseCaseDiffInfo loadUseCaseDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); List<ScenarioDiffInfo> loadScenarioDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); ScenarioDiffInfo loadScenarioDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); List<StepDiffInfo> loadStepDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); StepDiffInfo loadStepDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final int stepIndex); File getScreenshotFile(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final String imageName); File getBuildComparisonLogFile(final String baseBranchName, final String baseBuildName, final String comparisonName); DiffViewerBuildWriter getBuildDiffWriter(final String baseBranchName, final String baseBuildName, final String comparisonName); }
@Test void testWriteAndReadBuildDiffInfo() { final BuildDiffInfo buildDiffInfo = getBuildDiffInfo(COMPARISON_NAME); buildWriter.saveBuildDiffInfo(buildDiffInfo); final BuildDiffInfo actualBuildDiffInfo = dao.loadBuildDiffInfo(BASE_BRANCH_NAME, BASE_BUILD_NAME, COMPARISON_NAME); assertStructueDiffInfo(actualBuildDiffInfo, COMPARISON_NAME); }
DiffViewerDao { public UseCaseDiffInfo loadUseCaseDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName) { final File file = diffFiles.getUseCaseFile(baseBranchName, baseBuildName, comparisonName, useCaseName); return ScenarioDocuXMLFileUtil.unmarshal(UseCaseDiffInfo.class, file); } List<BuildDiffInfo> loadAllBuildDiffInfos(); List<BuildDiffInfo> loadBuildDiffInfos(final String baseBranchName, final String baseBuildName); BuildDiffInfo loadBuildDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName); List<UseCaseDiffInfo> loadUseCaseDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName); UseCaseDiffInfo loadUseCaseDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); List<ScenarioDiffInfo> loadScenarioDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); ScenarioDiffInfo loadScenarioDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); List<StepDiffInfo> loadStepDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); StepDiffInfo loadStepDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final int stepIndex); File getScreenshotFile(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final String imageName); File getBuildComparisonLogFile(final String baseBranchName, final String baseBuildName, final String comparisonName); DiffViewerBuildWriter getBuildDiffWriter(final String baseBranchName, final String baseBuildName, final String comparisonName); }
@Test void testWriteAndReadUseCaseDiffInfo() { final UseCaseDiffInfo useCaseDiffInfo = getUseCaseDiffInfo(USE_CASE_NAME); buildWriter.saveUseCaseDiffInfo(useCaseDiffInfo); final UseCaseDiffInfo actualUseCaseDiffInfo = dao.loadUseCaseDiffInfo(BASE_BRANCH_NAME, BASE_BUILD_NAME, COMPARISON_NAME, USE_CASE_NAME); assertStructueDiffInfo(actualUseCaseDiffInfo, USE_CASE_NAME); }
DiffViewerDao { public ScenarioDiffInfo loadScenarioDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName) { final File file = diffFiles.getScenarioFile(baseBranchName, baseBuildName, comparisonName, useCaseName, scenarioName); return ScenarioDocuXMLFileUtil.unmarshal(ScenarioDiffInfo.class, file); } List<BuildDiffInfo> loadAllBuildDiffInfos(); List<BuildDiffInfo> loadBuildDiffInfos(final String baseBranchName, final String baseBuildName); BuildDiffInfo loadBuildDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName); List<UseCaseDiffInfo> loadUseCaseDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName); UseCaseDiffInfo loadUseCaseDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); List<ScenarioDiffInfo> loadScenarioDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); ScenarioDiffInfo loadScenarioDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); List<StepDiffInfo> loadStepDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); StepDiffInfo loadStepDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final int stepIndex); File getScreenshotFile(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final String imageName); File getBuildComparisonLogFile(final String baseBranchName, final String baseBuildName, final String comparisonName); DiffViewerBuildWriter getBuildDiffWriter(final String baseBranchName, final String baseBuildName, final String comparisonName); }
@Test void testWriteAndReadScenarioDiffInfo() { final ScenarioDiffInfo scenarioDiffInfo = getScenarioDiffInfo(SCENARIO_NAME); buildWriter.saveScenarioDiffInfo(scenarioDiffInfo, USE_CASE_NAME); final ScenarioDiffInfo actualScenarioDiffInfo = dao.loadScenarioDiffInfo(BASE_BRANCH_NAME, BASE_BUILD_NAME, COMPARISON_NAME, USE_CASE_NAME, SCENARIO_NAME); assertStructueDiffInfo(actualScenarioDiffInfo, SCENARIO_NAME); }
DiffViewerDao { public StepDiffInfo loadStepDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final int stepIndex) { final File file = diffFiles.getStepFile(baseBranchName, baseBuildName, comparisonName, useCaseName, scenarioName, stepIndex); return ScenarioDocuXMLFileUtil.unmarshal(StepDiffInfo.class, file); } List<BuildDiffInfo> loadAllBuildDiffInfos(); List<BuildDiffInfo> loadBuildDiffInfos(final String baseBranchName, final String baseBuildName); BuildDiffInfo loadBuildDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName); List<UseCaseDiffInfo> loadUseCaseDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName); UseCaseDiffInfo loadUseCaseDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); List<ScenarioDiffInfo> loadScenarioDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); ScenarioDiffInfo loadScenarioDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); List<StepDiffInfo> loadStepDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); StepDiffInfo loadStepDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final int stepIndex); File getScreenshotFile(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final String imageName); File getBuildComparisonLogFile(final String baseBranchName, final String baseBuildName, final String comparisonName); DiffViewerBuildWriter getBuildDiffWriter(final String baseBranchName, final String baseBuildName, final String comparisonName); }
@Test void testWriteAndReadStepDiffInfo() { final StepDiffInfo stepDiffInfo = getStepDiffInfo(STEP_INDEX); buildWriter.saveStepDiffInfo(USE_CASE_NAME, SCENARIO_NAME, stepDiffInfo); final StepDiffInfo actualStepDiffInfo = dao.loadStepDiffInfo(BASE_BRANCH_NAME, BASE_BUILD_NAME, COMPARISON_NAME, USE_CASE_NAME, SCENARIO_NAME, STEP_INDEX); assertStepDiffInfo(actualStepDiffInfo, STEP_INDEX); }
DiffViewerDao { public List<UseCaseDiffInfo> loadUseCaseDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName) { final List<File> files = diffFiles.getUseCaseFiles(baseBranchName, baseBuildName, comparisonName); return ScenarioDocuXMLFileUtil.unmarshalListOfFiles(UseCaseDiffInfo.class, files); } List<BuildDiffInfo> loadAllBuildDiffInfos(); List<BuildDiffInfo> loadBuildDiffInfos(final String baseBranchName, final String baseBuildName); BuildDiffInfo loadBuildDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName); List<UseCaseDiffInfo> loadUseCaseDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName); UseCaseDiffInfo loadUseCaseDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); List<ScenarioDiffInfo> loadScenarioDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); ScenarioDiffInfo loadScenarioDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); List<StepDiffInfo> loadStepDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); StepDiffInfo loadStepDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final int stepIndex); File getScreenshotFile(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final String imageName); File getBuildComparisonLogFile(final String baseBranchName, final String baseBuildName, final String comparisonName); DiffViewerBuildWriter getBuildDiffWriter(final String baseBranchName, final String baseBuildName, final String comparisonName); }
@Test void testWriteAndReadUseCaseDiffInfos() { for (int i = 0; i < NUMBER_OF_FILES; i++) { final UseCaseDiffInfo useCaseDiffInfo = getUseCaseDiffInfo(USE_CASE_NAME + i); buildWriter.saveUseCaseDiffInfo(useCaseDiffInfo); } final List<UseCaseDiffInfo> actualUseCaseDiffInfos = dao.loadUseCaseDiffInfos(BASE_BRANCH_NAME, BASE_BUILD_NAME, COMPARISON_NAME); assertEquals(2, actualUseCaseDiffInfos.size()); for (int i = 0; i < NUMBER_OF_FILES; i++) { assertStructueDiffInfo(actualUseCaseDiffInfos.get(i), USE_CASE_NAME + i); } }
DiffViewerDao { public List<ScenarioDiffInfo> loadScenarioDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName) { final List<File> files = diffFiles.getScenarioFiles(baseBranchName, baseBuildName, comparisonName, useCaseName); return ScenarioDocuXMLFileUtil.unmarshalListOfFiles(ScenarioDiffInfo.class, files); } List<BuildDiffInfo> loadAllBuildDiffInfos(); List<BuildDiffInfo> loadBuildDiffInfos(final String baseBranchName, final String baseBuildName); BuildDiffInfo loadBuildDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName); List<UseCaseDiffInfo> loadUseCaseDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName); UseCaseDiffInfo loadUseCaseDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); List<ScenarioDiffInfo> loadScenarioDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); ScenarioDiffInfo loadScenarioDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); List<StepDiffInfo> loadStepDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); StepDiffInfo loadStepDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final int stepIndex); File getScreenshotFile(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final String imageName); File getBuildComparisonLogFile(final String baseBranchName, final String baseBuildName, final String comparisonName); DiffViewerBuildWriter getBuildDiffWriter(final String baseBranchName, final String baseBuildName, final String comparisonName); }
@Test void testWriteAndReadScenarioDiffInfos() { for (int i = 0; i < NUMBER_OF_FILES; i++) { final ScenarioDiffInfo scenarioDiffInfo = getScenarioDiffInfo(SCENARIO_NAME + i); buildWriter.saveScenarioDiffInfo(scenarioDiffInfo, USE_CASE_NAME); } final List<ScenarioDiffInfo> actualScenarioDiffInfos = dao.loadScenarioDiffInfos(BASE_BRANCH_NAME, BASE_BUILD_NAME, COMPARISON_NAME, USE_CASE_NAME); assertEquals(2, actualScenarioDiffInfos.size()); for (int i = 0; i < NUMBER_OF_FILES; i++) { assertStructueDiffInfo(actualScenarioDiffInfos.get(i), SCENARIO_NAME + i); } }
DiffViewerDao { public List<StepDiffInfo> loadStepDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName) { final List<File> files = diffFiles.getStepFiles(baseBranchName, baseBuildName, comparisonName, useCaseName, scenarioName); return ScenarioDocuXMLFileUtil.unmarshalListOfFiles(StepDiffInfo.class, files); } List<BuildDiffInfo> loadAllBuildDiffInfos(); List<BuildDiffInfo> loadBuildDiffInfos(final String baseBranchName, final String baseBuildName); BuildDiffInfo loadBuildDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName); List<UseCaseDiffInfo> loadUseCaseDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName); UseCaseDiffInfo loadUseCaseDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); List<ScenarioDiffInfo> loadScenarioDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName); ScenarioDiffInfo loadScenarioDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); List<StepDiffInfo> loadStepDiffInfos(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName); StepDiffInfo loadStepDiffInfo(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final int stepIndex); File getScreenshotFile(final String baseBranchName, final String baseBuildName, final String comparisonName, final String useCaseName, final String scenarioName, final String imageName); File getBuildComparisonLogFile(final String baseBranchName, final String baseBuildName, final String comparisonName); DiffViewerBuildWriter getBuildDiffWriter(final String baseBranchName, final String baseBuildName, final String comparisonName); }
@Test void testWriteAndReadStepDiffInfos() { for (int i = 0; i < NUMBER_OF_FILES; i++) { final StepDiffInfo stepDiffInfo = getStepDiffInfo(STEP_INDEX + i); buildWriter.saveStepDiffInfo(USE_CASE_NAME, SCENARIO_NAME, stepDiffInfo); } final List<StepDiffInfo> actualStepDiffInfos = dao.loadStepDiffInfos(BASE_BRANCH_NAME, BASE_BUILD_NAME, COMPARISON_NAME, USE_CASE_NAME, SCENARIO_NAME); assertEquals(2, actualStepDiffInfos.size()); for (int i = 0; i < NUMBER_OF_FILES; i++) { assertStepDiffInfo(actualStepDiffInfos.get(i), STEP_INDEX + i); } }
FullTextSearch { public void indexUseCases(final UseCaseScenariosList useCaseScenariosList, final BuildIdentifier buildIdentifier) { if(!searchAdapter.isEngineRunning()) { return; } searchAdapter.setupNewBuild(buildIdentifier); searchAdapter.indexUseCases(useCaseScenariosList, buildIdentifier); LOGGER.info("Indexed use cases for build " + buildIdentifier); } FullTextSearch(); FullTextSearch(final SearchAdapter search); boolean isEngineRunning(); String getEndpoint(); boolean isSearchEngineEndpointConfigured(); SearchTree search(SearchRequest searchRequest); void indexUseCases(final UseCaseScenariosList useCaseScenariosList, final BuildIdentifier buildIdentifier); void indexSteps(final List<Step> steps, final List<StepLink> stepLinkList, final Scenario scenario, final UseCase usecase, final BuildIdentifier buildIdentifier); void updateAvailableBuilds(final List<BuildImportSummary> availableBuilds); static final String STEP; static final String SCENARIO; static final String USECASE; }
@Test void indexUseCaseWithoutRunningEngine() { givenNoRunningEngine(); fullTextSearch.indexUseCases(new UseCaseScenariosList(), new BuildIdentifier("testBranch", "testBuild")); thenJustReturns(); }