public void testForMapWithDefault() { Map<String, Integer> map = Maps.newHashMap(); map.put("One", 1); map.put("Three", 3); map.put("Null", null); Function<String, Integer> function = Functions.forMap(map, 42); assertEquals(1, function.apply("One").intValue()); assertEquals(42, function.apply("Two").intValue()); assertEquals(3, function.apply("Three").intValue()); assertNull(function.apply("Null")); new EqualsTester() .addEqualityGroup(function, Functions.forMap(map, 42)) .addEqualityGroup(Functions.forMap(map)) .addEqualityGroup(Functions.forMap(map, null)) .addEqualityGroup(Functions.forMap(map, 43)) .testEquals(); }
public void testForPredicate() { Function<Object, Boolean> alwaysTrue = Functions.forPredicate(Predicates.alwaysTrue()); Function<Object, Boolean> alwaysFalse = Functions.forPredicate(Predicates.alwaysFalse()); assertTrue(alwaysTrue.apply(0)); assertFalse(alwaysFalse.apply(0)); new EqualsTester() .addEqualityGroup(alwaysTrue, Functions.forPredicate(Predicates.alwaysTrue())) .addEqualityGroup(alwaysFalse) .addEqualityGroup(Functions.identity()) .testEquals(); }
public void testIdentity_notSame() { Function<Long, Long> identity = Functions.identity(); assertNotSame(new Long(135135L), identity.apply(new Long(135135L))); }
public void testIdentity_same() { Function<String, String> identity = Functions.identity(); assertNull(identity.apply(null)); assertSame("foo", identity.apply("foo")); }
@GwtIncompatible // SerializableTester private static <Y> void checkCanReserializeSingleton(Function<? super String, Y> f) { Function<? super String, Y> g = SerializableTester.reserializeAndAssert(f); assertSame(f, g); for (Integer i = 1; i < 5; i++) { assertEquals(f.apply(i.toString()), g.apply(i.toString())); } } }
public void testToStringFunction_apply() { assertEquals("3", Functions.toStringFunction().apply(3)); assertEquals("hiya", Functions.toStringFunction().apply("hiya")); assertEquals( "I'm a string", Functions.toStringFunction() .apply( new Object() { @Override public String toString() { return "I'm a string"; } })); try { Functions.toStringFunction().apply(null); fail("expected NullPointerException"); } catch (NullPointerException expected) { } }
public void testForMapWithoutDefault() { Map<String, Integer> map = Maps.newHashMap(); map.put("One", 1); map.put("Three", 3); map.put("Null", null); Function<String, Integer> function = Functions.forMap(map); assertEquals(1, function.apply("One").intValue()); assertEquals(3, function.apply("Three").intValue()); assertNull(function.apply("Null")); try { function.apply("Two"); fail(); } catch (IllegalArgumentException expected) { } new EqualsTester() .addEqualityGroup(function, Functions.forMap(map)) .addEqualityGroup(Functions.forMap(map, 42)) .testEquals(); }
public void testForMapWildCardWithDefault() { Map<String, Integer> map = Maps.newHashMap(); map.put("One", 1); map.put("Three", 3); Number number = Double.valueOf(42); Function<String, Number> function = Functions.forMap(map, number); assertEquals(1, function.apply("One").intValue()); assertEquals(number, function.apply("Two")); assertEquals(3L, function.apply("Three").longValue()); }
@GwtIncompatible // SerializableTester public void testForMapWithoutDefaultSerializable() { checkCanReserialize(Functions.forMap(ImmutableMap.of(1, 2))); }
@GwtIncompatible // SerializableTester public void testIdentitySerializable() { checkCanReserializeSingleton(Functions.identity()); }
@GwtIncompatible // SerializableTester private static <Y> void checkCanReserialize(Function<? super Integer, Y> f) { Function<? super Integer, Y> g = SerializableTester.reserializeAndAssert(f); for (int i = 1; i < 5; i++) { // convoluted way to check that the same result happens from each Y expected = null; try { expected = f.apply(i); } catch (IllegalArgumentException e) { try { g.apply(i); fail(); } catch (IllegalArgumentException ok) { continue; } } assertEquals(expected, g.apply(i)); } }
public void testForMapWithoutDefault() { Map<String, Integer> map = Maps.newHashMap(); map.put("One", 1); map.put("Three", 3); map.put("Null", null); Function<String, Integer> function = Functions.forMap(map); assertEquals(1, function.apply("One").intValue()); assertEquals(3, function.apply("Three").intValue()); assertNull(function.apply("Null")); try { function.apply("Two"); fail(); } catch (IllegalArgumentException expected) { } new EqualsTester() .addEqualityGroup(function, Functions.forMap(map)) .addEqualityGroup(Functions.forMap(map, 42)) .testEquals(); }
public void testComposeOfPredicateAndFunctionIsAssociative() { Map<Float, String> m = ImmutableMap.of(4.0f, "A", 3.0f, "B", 2.0f, "C", 1.0f, "D"); Predicate<? super Integer> h = Predicates.equalTo(42); Function<? super String, Integer> g = new HashCodeFunction(); Function<Float, String> f = Functions.forMap(m, "F"); Predicate<Float> p1 = Predicates.compose(Predicates.compose(h, g), f); Predicate<Float> p2 = Predicates.compose(h, Functions.compose(g, f)); // Might be nice (eventually) to have: // assertEquals(p1, p2); // But for now, settle for this: assertEquals(p1.hashCode(), p2.hashCode()); assertEquals(p1.apply(1.0f), p2.apply(1.0f)); assertEquals(p1.apply(5.0f), p2.apply(5.0f)); }
@GwtIncompatible // SerializableTester public void testForMapWithDefaultSerializable() { checkCanReserialize(Functions.forMap(ImmutableMap.of(1, 2), 3)); }
public void testIdentity_same() { Function<String, String> identity = Functions.identity(); assertNull(identity.apply(null)); assertSame("foo", identity.apply("foo")); }
@GwtIncompatible // SerializableTester private static <Y> void checkCanReserializeSingleton(Function<? super String, Y> f) { Function<? super String, Y> g = SerializableTester.reserializeAndAssert(f); assertSame(f, g); for (Integer i = 1; i < 5; i++) { assertEquals(f.apply(i.toString()), g.apply(i.toString())); } }
@GwtIncompatible // SerializableTester public void testToStringFunctionSerializable() { checkCanReserializeSingleton(Functions.toStringFunction()); }
public void testForMapWithDefault_null() { ImmutableMap<String, Integer> map = ImmutableMap.of("One", 1); Function<String, Integer> function = Functions.forMap(map, null); assertEquals((Integer) 1, function.apply("One")); assertNull(function.apply("Two")); // check basic sanity of equals and hashCode new EqualsTester() .addEqualityGroup(function) .addEqualityGroup(Functions.forMap(map, 1)) .testEquals(); }
Functions.compose(integerToSpanish, japaneseToInteger); assertEquals("Uno", japaneseToSpanish.apply("Ichi")); try { japaneseToSpanish.apply("Ni"); fail(); } catch (IllegalArgumentException e) { assertEquals("Tres", japaneseToSpanish.apply("San")); try { japaneseToSpanish.apply("Shi"); fail(); } catch (IllegalArgumentException e) {
public void testComposeOfFunctionsIsAssociative() { Map<Float, String> m = ImmutableMap.of(4.0f, "A", 3.0f, "B", 2.0f, "C", 1.0f, "D"); Function<? super Integer, Boolean> h = Functions.constant(Boolean.TRUE); Function<? super String, Integer> g = new HashCodeFunction(); Function<Float, String> f = Functions.forMap(m, "F"); Function<Float, Boolean> c1 = Functions.compose(Functions.compose(h, g), f); Function<Float, Boolean> c2 = Functions.compose(h, Functions.compose(g, f)); // Might be nice (eventually) to have: // assertEquals(c1, c2); // But for now, settle for this: assertEquals(c1.hashCode(), c2.hashCode()); assertEquals(c1.apply(1.0f), c2.apply(1.0f)); assertEquals(c1.apply(5.0f), c2.apply(5.0f)); }