org.junit.internal.ArrayComparisonFailure Java Examples

/** */
@Test
public void duplicateRandomFeatures() {
    VectorGenerator g1 = VectorGeneratorPrimitives.constant(VectorUtils.of(1., 2., 3., 4.))
        .duplicateRandomFeatures(2, 1L);

    double[] exp = {1., 2., 3., 4., 3., 1.};
    Vector v1 = g1.get();
    Vector v2 = g1.get();

    assertArrayEquals(exp, v1.asArray(), 1e-7);

    try {
        assertArrayEquals(v1.asArray(), v2.asArray(), 1e-7);
    }
    catch (ArrayComparisonFailure e) {
        //this is valid situation - duplicator should get different features
    }
}
 

protected void serializeObject( final Object referenceObject, final QExpressions qe, final String expr ) throws IOException, QException,
        ArrayComparisonFailure {
    final ByteArrayOutputStream stream = new ByteArrayOutputStream();
    final QWriter writer = new DefaultQWriter();
    writer.setStream(stream);
    writer.setEncoding("ISO-8859-1");
    writer.write(referenceObject, QConnection.MessageType.SYNC);

    final byte[] out = stream.toByteArray();

    assertArrayEquals("Serialization failed for q expression: " + expr, qe.getBinaryExpression(expr), copyOfRange(out, 8, out.length));
}
 

private void tryHexEncoding(long seed) throws ArrayComparisonFailure
{
    byte[] bytes = createRandomByteArray(128, seed);

    String encodedBytes = Type1FontUtil.hexEncode(bytes);
    byte[] decodedBytes = Type1FontUtil.hexDecode(encodedBytes);

    assertArrayEquals("Seed: " + seed, bytes, decodedBytes);
}
 

private void tryEexecEncryption(long seed) throws ArrayComparisonFailure
{
    byte[] bytes = createRandomByteArray(128, seed);

    byte[] encryptedBytes = Type1FontUtil.eexecEncrypt(bytes);
    byte[] decryptedBytes = Type1FontUtil.eexecDecrypt(encryptedBytes);

    assertArrayEquals("Seed: " + seed, bytes, decryptedBytes);
}
 

private void tryCharstringEncryption(long seed) throws ArrayComparisonFailure
{
    byte[] bytes = createRandomByteArray(128, seed);

    byte[] encryptedBytes = Type1FontUtil.charstringEncrypt(bytes, 4);
    byte[] decryptedBytes = Type1FontUtil.charstringDecrypt(encryptedBytes, 4);

    assertArrayEquals("Seed: " + seed, bytes, decryptedBytes);
}
 

private void testGetWithExhaustiveWebMapping(AnnotatedElement element) throws ArrayComparisonFailure {
	MergedAnnotation<?> annotation = MergedAnnotations.from(element,
			SearchStrategy.EXHAUSTIVE).get(RequestMapping.class);
	assertThat(annotation.getStringArray("value")).containsExactly("/test");
	assertThat(annotation.getStringArray("path")).containsExactly("/test");
}
 

private void assertWebMapping(AnnotatedElement element) throws ArrayComparisonFailure {
	WebMapping webMapping = findMergedAnnotation(element, WebMapping.class);
	assertNotNull(webMapping);
	assertArrayEquals("value attribute: ", asArray("/test"), webMapping.value());
	assertArrayEquals("path attribute: ", asArray("/test"), webMapping.path());
}
 

private void assertWebMapping(AnnotatedElement element) throws ArrayComparisonFailure {
	WebMapping webMapping = findMergedAnnotation(element, WebMapping.class);
	assertNotNull(webMapping);
	assertArrayEquals("value attribute: ", asArray("/test"), webMapping.value());
	assertArrayEquals("path attribute: ", asArray("/test"), webMapping.path());
}
 

private void checkObservedPropertiesFor(MultiDatastream md, ObservedProperty... expectedObservedProps) throws ArrayComparisonFailure, ServiceFailureException {
    ObservedProperty[] fetchedObservedProps2 = md.observedProperties().query().list().toArray(new ObservedProperty[0]);
    String message = "Incorrect Observed Properties returned.";
    Assert.assertArrayEquals(message, expectedObservedProps, fetchedObservedProps2);
}
 

@Test
  public void testSFAWordsWindowing() {
    int symbols = 4;
    int wordLength = 4;
    boolean normMean = true;


    // Load the train/test splits
    ClassLoader classLoader = SFAWordsTest.class.getClassLoader();
    TimeSeries[] train = TimeSeriesLoader.loadDataset(classLoader.getResource("datasets/univariate/BEEF/BEEF_TRAIN").getFile());

    // test 120 window sizes
    for (int w = 4; w < 120; w++) {
      double[][] bins = null;
      int[] bestValues = null;
      ArrayList<SFA.ValueLabel>[] orderLine = null;

      // test for reproducible splits
      for (int i = 0; i < 3; i++) {
        SFASupervised sfa = new SFASupervised(HistogramType.INFORMATION_GAIN);

        // train SFA representation
        sfa.fitWindowing(train, w, wordLength, symbols, normMean, false);

        // bins
        if (bins != null) {
          try {
            Assert.assertArrayEquals(bins, sfa.bins);
          } catch (ArrayComparisonFailure ex) {

            System.out.println(Arrays.toString(sfa.bestValues));
            System.out.println(Arrays.toString(bestValues));


//            output :
//            for (int a = 0; a < bins.length; a++) {
//              for (int b = 0; b < bins[a].length; b++) {
//                if (bins[a][b]!=sfa.bins[a][b]) {
//                  System.out.println(orderLine[a]);
//                  System.out.println(sfa.orderLine[a]);
//
//                  ArrayList<Integer> splitPoints = new ArrayList<>();
//                  sfa.findBestSplit(orderLine[a], 0, orderLine[a].size(), symbols, splitPoints);
//                  System.out.println(Arrays.toString(splitPoints.toArray(new Integer[]{})));
//
//                  // test if the split points are the same
//                  for (int x = 0; x < 10; x++) {
//                    splitPoints = new ArrayList<>();
//                    sfa.findBestSplit(orderLine[a], 0, orderLine[a].size(), symbols, splitPoints);
//
//                    System.out.println("Splitpoints");
//                    for (int split : splitPoints) {
//                      System.out.println(orderLine[a].get(split + 1).value);
//                    }
//                  }
//
//                  break output;
//                }
//              }
//            }


            System.out.println(w);

            sfa.printBins();
            sfa.bins = bins;
            sfa.printBins();

            throw ex;
          }
        }

        bestValues = sfa.bestValues;
        bins = sfa.bins;
        orderLine = sfa.orderLine;
      }
    }

    System.out.println("Test passed");
  }
 

/**
 * Asserts that two float arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code>
 * okay)
 * @param expecteds float array with expected values.
 * @param actuals float array with actual values
 * @param delta the maximum delta between <code>expecteds[i]</code> and
 * <code>actuals[i]</code> for which both numbers are still
 * considered equal.
 */
public static void assertArrayEquals(String message, float[] expecteds,
        float[] actuals, float delta) throws ArrayComparisonFailure {
    new InexactComparisonCriteria(delta).arrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two object arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message. If
 * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
 * they are considered equal.
 *
 * @param message   the identifying message for the {@link AssertionError} (<code>null</code>
 *                  okay)
 * @param expecteds Object array or array of arrays (multi-dimensional array) with
 *                  expected values.
 * @param actuals   Object array or array of arrays (multi-dimensional array) with
 *                  actual values
 */
private static void internalArrayEquals(String message, Object expecteds,
                                        Object actuals) throws ArrayComparisonFailure {
    new ExactComparisonCriteria().arrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two object arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message. If
 * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
 * they are considered equal.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code>
 * okay)
 * @param expecteds Object array or array of arrays (multi-dimensional array) with
 * expected values.
 * @param actuals Object array or array of arrays (multi-dimensional array) with
 * actual values
 */
private static void internalArrayEquals(String message, Object expecteds,
        Object actuals) throws ArrayComparisonFailure {
    new ExactComparisonCriteria().arrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two object arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message. If
 * <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
 * they are considered equal.
 *
 * @param message   the identifying message for the {@link AssertionError} (<code>null</code>
 *                  okay)
 * @param expecteds Object array or array of arrays (multi-dimensional array) with
 *                  expected values.
 * @param actuals   Object array or array of arrays (multi-dimensional array) with
 *                  actual values
 */
public static void assertArrayEquals(String message, Object[] expecteds,
                                     Object[] actuals) throws ArrayComparisonFailure {
    internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two byte arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message.
 *
 * @param message   the identifying message for the {@link AssertionError} (<code>null</code>
 *                  okay)
 * @param expecteds byte array with expected values.
 * @param actuals   byte array with actual values
 */
public static void assertArrayEquals(String message, byte[] expecteds,
                                     byte[] actuals) throws ArrayComparisonFailure {
    internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two char arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message.
 *
 * @param message   the identifying message for the {@link AssertionError} (<code>null</code>
 *                  okay)
 * @param expecteds char array with expected values.
 * @param actuals   char array with actual values
 */
public static void assertArrayEquals(String message, char[] expecteds,
                                     char[] actuals) throws ArrayComparisonFailure {
    internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two short arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message.
 *
 * @param message   the identifying message for the {@link AssertionError} (<code>null</code>
 *                  okay)
 * @param expecteds short array with expected values.
 * @param actuals   short array with actual values
 */
public static void assertArrayEquals(String message, short[] expecteds,
                                     short[] actuals) throws ArrayComparisonFailure {
    internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two int arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message.
 *
 * @param message   the identifying message for the {@link AssertionError} (<code>null</code>
 *                  okay)
 * @param expecteds int array with expected values.
 * @param actuals   int array with actual values
 */
public static void assertArrayEquals(String message, int[] expecteds,
                                     int[] actuals) throws ArrayComparisonFailure {
    internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two long arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message.
 *
 * @param message   the identifying message for the {@link AssertionError} (<code>null</code>
 *                  okay)
 * @param expecteds long array with expected values.
 * @param actuals   long array with actual values
 */
public static void assertArrayEquals(String message, long[] expecteds,
                                     long[] actuals) throws ArrayComparisonFailure {
    internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two double arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message.
 *
 * @param message   the identifying message for the {@link AssertionError} (<code>null</code>
 *                  okay)
 * @param expecteds double array with expected values.
 * @param actuals   double array with actual values
 */
public static void assertArrayEquals(String message, double[] expecteds,
                                     double[] actuals, double delta) throws ArrayComparisonFailure {
    new InexactComparisonCriteria(delta).arrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two float arrays are equal. If they are not, an
 * {@link AssertionError} is thrown with the given message.
 *
 * @param message   the identifying message for the {@link AssertionError} (<code>null</code>
 *                  okay)
 * @param expecteds float array with expected values.
 * @param actuals   float array with actual values
 */
public static void assertArrayEquals(String message, float[] expecteds,
                                     float[] actuals, float delta) throws ArrayComparisonFailure {
    new InexactComparisonCriteria(delta).arrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two float arrays are equal. If they are not, an {@link AssertionError} is thrown
 * with the given message.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code> okay)
 * @param expecteds float array with expected values.
 * @param actuals float array with actual values
 * @param delta the maximum delta between <code>expecteds[i]</code> and <code>actuals[i]</code>
 *     for which both numbers are still considered equal.
 */
public static void assertArrayEquals(
    String message, float[] expecteds, float[] actuals, float delta)
    throws ArrayComparisonFailure {
  new InexactComparisonCriteria(delta).arrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two object arrays are equal. If they are not, an {@link AssertionError} is thrown
 * with the given message. If <code>expecteds</code> and <code>actuals</code> are <code>null
 * </code>, they are considered equal.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code> okay)
 * @param expecteds Object array or array of arrays (multi-dimensional array) with expected
 *     values.
 * @param actuals Object array or array of arrays (multi-dimensional array) with actual values
 */
public static void assertArrayEquals(String message, Object[] expecteds, Object[] actuals)
    throws ArrayComparisonFailure {
  internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two boolean arrays are equal. If they are not, an {@link AssertionError} is thrown
 * with the given message. If <code>expecteds</code> and <code>actuals</code> are <code>null
 * </code>, they are considered equal.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code> okay)
 * @param expecteds boolean array with expected values.
 * @param actuals boolean array with expected values.
 */
public static void assertArrayEquals(String message, boolean[] expecteds, boolean[] actuals)
    throws ArrayComparisonFailure {
  internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two byte arrays are equal. If they are not, an {@link AssertionError} is thrown
 * with the given message.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code> okay)
 * @param expecteds byte array with expected values.
 * @param actuals byte array with actual values
 */
public static void assertArrayEquals(String message, byte[] expecteds, byte[] actuals)
    throws ArrayComparisonFailure {
  internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two char arrays are equal. If they are not, an {@link AssertionError} is thrown
 * with the given message.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code> okay)
 * @param expecteds char array with expected values.
 * @param actuals char array with actual values
 */
public static void assertArrayEquals(String message, char[] expecteds, char[] actuals)
    throws ArrayComparisonFailure {
  internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two short arrays are equal. If they are not, an {@link AssertionError} is thrown
 * with the given message.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code> okay)
 * @param expecteds short array with expected values.
 * @param actuals short array with actual values
 */
public static void assertArrayEquals(String message, short[] expecteds, short[] actuals)
    throws ArrayComparisonFailure {
  internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two int arrays are equal. If they are not, an {@link AssertionError} is thrown
 * with the given message.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code> okay)
 * @param expecteds int array with expected values.
 * @param actuals int array with actual values
 */
public static void assertArrayEquals(String message, int[] expecteds, int[] actuals)
    throws ArrayComparisonFailure {
  internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two long arrays are equal. If they are not, an {@link AssertionError} is thrown
 * with the given message.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code> okay)
 * @param expecteds long array with expected values.
 * @param actuals long array with actual values
 */
public static void assertArrayEquals(String message, long[] expecteds, long[] actuals)
    throws ArrayComparisonFailure {
  internalArrayEquals(message, expecteds, actuals);
}
 

/**
 * Asserts that two double arrays are equal. If they are not, an {@link AssertionError} is thrown
 * with the given message.
 *
 * @param message the identifying message for the {@link AssertionError} (<code>null</code> okay)
 * @param expecteds double array with expected values.
 * @param actuals double array with actual values
 * @param delta the maximum delta between <code>expecteds[i]</code> and <code>actuals[i]</code>
 *     for which both numbers are still considered equal.
 */
public static void assertArrayEquals(
    String message, double[] expecteds, double[] actuals, double delta)
    throws ArrayComparisonFailure {
  new InexactComparisonCriteria(delta).arrayEquals(message, expecteds, actuals);
}