public static <T> void assertContainsSame(Collection<T> expected, Collection<T> actual) { if (expected == null) { assertNull(actual); } else { assertNotNull(actual); assertEquals(expected.size(), actual.size()); if (!expected.containsAll(actual)) { fail("Found unexpected values " + minus(actual, expected)); } if (!actual.containsAll(expected)) { fail("Missing values " + minus(expected, actual)); } } }
public static void assertRange(double a, double min, double max) { assertGreaterOrEqual(a, min); assertLessOrEqual(a, max); }
public static <T> void assertContains(Collection<T> collection, T value) { assertTrue(abbreviatedToString(collection) + " should contain " + value, collection.contains(value)); }
public static <T> void assertNotContains(Collection<T> collection, T value) { assertFalse(abbreviatedToString(collection) + " should not contain " + value, collection.contains(value)); }
private static void testCSVTop(int expectedSize, String response, boolean counts, boolean reverse) { String[] rows = response.split("\n"); Assert.assertEquals(expectedSize, rows.length); for (int i = 0; i < rows.length; i++) { String row = rows[i]; String[] tokens = row.split(","); if (counts) { int count = Integer.parseInt(tokens[1]); OryxTest.assertGreater(count, 0); } double thisScore = Double.parseDouble(tokens[1]); Assert.assertFalse(Double.isNaN(thisScore)); Assert.assertFalse(Double.isInfinite(thisScore)); if (i > 0) { double lastScore = Double.parseDouble(rows[i-1].split(",")[1]); if (reverse) { OryxTest.assertLessOrEqual(lastScore, thisScore); } else { OryxTest.assertGreaterOrEqual(lastScore, thisScore); } } } }
/** * Asserts that two {@code float} values are equal or very close -- that the absolute value of their * difference is at most {@link #FLOAT_EPSILON}. * * @param expected test's expected value * @param actual actual value */ public static void assertEquals(float expected, float actual) { assertEquals(expected, actual, FLOAT_EPSILON); }
static void testTopCount(int expectedSize, List<IDCount> top) { Assert.assertEquals(expectedSize, top.size()); for (int i = 0; i < top.size(); i++) { int thisCount = top.get(i).getCount(); OryxTest.assertGreaterOrEqual(thisCount, 1); if (i > 0) { OryxTest.assertGreaterOrEqual(top.get(i - 1).getCount(), thisCount); } } }
@Test public void testKnownItemsCSV() { String response = target("/knownItems/U1").request().get(String.class); List<String> items = Arrays.asList(response.split("\n")); Assert.assertEquals(5, items.size()); for (int i : new int[] {1, 4, 5, 7, 8}) { OryxTest.assertContains(items, "I" + i); } }
public static void assertArrayEquals(float[] expecteds, float[] actuals) { assertArrayEquals(expecteds, actuals, FLOAT_EPSILON); }
/** * Asserts that two {@code double} values are equal or very close -- that the absolute value of their * difference is at most {@link #DOUBLE_EPSILON}. * * @param expected test's expected value * @param actual actual value */ @SuppressWarnings("deprecation") public static void assertEquals(double expected, double actual) { assertEquals(expected, actual, DOUBLE_EPSILON); }
@Test public void testPopularRepresentativeItems() { List<String> items = target("/popularRepresentativeItems").request() .accept(MediaType.APPLICATION_JSON_TYPE).get(LIST_STRING_TYPE); Assert.assertEquals(2, items.size()); // These are tied in the current model: OryxTest.assertContains(Arrays.asList("I0", "I3"), items.get(0)); Assert.assertEquals("I4", items.get(1)); }
public static void assertArrayEquals(double[] expecteds, double[] actuals) { assertArrayEquals(expecteds, actuals, DOUBLE_EPSILON); }
static void testTopByValue(int expectedSize, List<IDValue> values, boolean reverse) { Assert.assertEquals(expectedSize, values.size()); for (int i = 0; i < values.size(); i++) { IDValue value = values.get(i); double thisScore = value.getValue(); Assert.assertFalse(Double.isNaN(thisScore)); Assert.assertFalse(Double.isInfinite(thisScore)); if (i > 0) { double lastScore = values.get(i-1).getValue(); if (reverse) { OryxTest.assertLessOrEqual(lastScore, thisScore); } else { OryxTest.assertGreaterOrEqual(lastScore, thisScore); } } } }
@Test public void testSumWithNaN() throws Exception { OryxTest.assertEquals(1.0, MLFunctions.SUM_WITH_NAN.call(Arrays.asList(1.0)).doubleValue()); OryxTest.assertEquals(6.0, MLFunctions.SUM_WITH_NAN.call(Arrays.asList(1.0, 2.0, 3.0)).doubleValue()); OryxTest.assertEquals(3.0, MLFunctions.SUM_WITH_NAN.call(Arrays.asList(1.0, Double.NaN, 3.0)).doubleValue()); assertNaN(MLFunctions.SUM_WITH_NAN.call(Arrays.asList(1.0, 2.0, Double.NaN))); assertNaN(MLFunctions.SUM_WITH_NAN.call(Arrays.asList(Double.NaN))); }
@Test public void testKnownItems() { List<String> items = target("/knownItems/U1").request() .accept(MediaType.APPLICATION_JSON_TYPE).get(LIST_STRING_TYPE); Assert.assertEquals(5, items.size()); for (int i : new int[] {1, 4, 5, 7, 8}) { OryxTest.assertContains(items, "I" + i); } }
@Test public void testAllItemIDs() { List<String> users = target("/user/allIDs").request() .accept(MediaType.APPLICATION_JSON_TYPE).get(LIST_STRING_TYPE); Assert.assertEquals(7, users.size()); for (int user = 0; user < 7; user++) { OryxTest.assertContains(users, "U" + user); } }
@Test public void testAllItemIDs() { List<String> items = target("/item/allIDs").request() .accept(MediaType.APPLICATION_JSON_TYPE).get(LIST_STRING_TYPE); Assert.assertEquals(9, items.size()); for (int item = 0; item < 9; item++) { OryxTest.assertContains(items, "I" + item); } }