test/com/google/common/base/FunctionsTest.java - platform/external/guava - Git at Google

 /*
  * Copyright (C) 2005 Google Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.google.common.base;

 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
 import com.google.common.testutils.EqualsTester;
 import com.google.common.testutils.NullPointerTester;
 import com.google.common.testutils.SerializableTester;

 import junit.framework.TestCase;

 import java.util.Map;

 /**
  * Tests for {@link Functions}.
  *
  * @author Mike Bostock
  * @author Vlad Patryshev
  */
 public class FunctionsTest extends TestCase {

   public void testIdentity() {
     Function<String, String> identity = Functions.identity();
     assertNull(identity.apply(null));
     assertSame("foo", identity.apply("foo"));
     assertNotSame("foo", identity.apply(new String("foo")));

     checkCanReserializeSingleton(Functions.identity());
   }

   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 e) {
       // expected
     }

     checkCanReserializeSingleton(Functions.toStringFunction());
   }

   public void testNullPointerExceptions() throws Exception {
     NullPointerTester tester = new NullPointerTester();
     tester.testAllPublicStaticMethods(Functions.class);
   }

   public void testForMapWithoutDefault() {
     Map<String, Integer> map = Maps.newHashMap();
     map.put("One", 1);
     map.put("Three", 3);
     Function<String, Integer> function = Functions.forMap(map);

     assertEquals(1, function.apply("One").intValue());
     assertEquals(3, function.apply("Three").intValue());

     try {
       function.apply("Two");
       fail();
     } catch (IllegalArgumentException expected) {
     }

     new EqualsTester(function)
         .addEqualObject(Functions.forMap(map))
         .addEqualObject(Functions.forMap(map))
         .addNotEqualObject(Functions.forMap(map, 42))
         .testEquals();

     checkCanReserialize(Functions.forMap(ImmutableMap.of(1, 2)));
   }

   public void testForMapWithDefault() {
     Map<String, Integer> map = Maps.newHashMap();
     map.put("One", 1);
     map.put("Three", 3);
     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());

     new EqualsTester(function)
         .addEqualObject(Functions.forMap(map, 42))
         .addEqualObject(SerializableTester.reserialize(function))
         .addNotEqualObject(Functions.forMap(map))
         .addNotEqualObject(Functions.forMap(map, null))
         .addNotEqualObject(Functions.forMap(map, 43))
         .testEquals();

     checkCanReserialize(Functions.forMap(ImmutableMap.of(1, 2), 3));
   }

   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(function)
         .addEqualObject(SerializableTester.reserialize(function))
         .addNotEqualObject(Functions.forMap(map, 1))
         .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());
   }

   public void testComposition() {
     Map<String, Integer> mJapaneseToInteger = Maps.newHashMap();
     mJapaneseToInteger.put("Ichi", 1);
     mJapaneseToInteger.put("Ni", 2);
     mJapaneseToInteger.put("San", 3);
     Function<String, Integer> japaneseToInteger =
         Functions.forMap(mJapaneseToInteger);

     Map<Integer, String> mIntegerToSpanish = Maps.newHashMap();
     mIntegerToSpanish.put(1, "Uno");
     mIntegerToSpanish.put(3, "Tres");
     mIntegerToSpanish.put(4, "Cuatro");
     Function<Integer, String> integerToSpanish =
         Functions.forMap(mIntegerToSpanish);

     Function<String, String> japaneseToSpanish =
         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) {
     }

     new EqualsTester(japaneseToSpanish)
         .addEqualObject(
             Functions.compose(integerToSpanish, japaneseToInteger))
         .addEqualObject(
             SerializableTester.reserialize(japaneseToSpanish))
         .addNotEqualObject(japaneseToInteger)
         .addNotEqualObject(integerToSpanish)
         .addNotEqualObject(
             Functions.compose(japaneseToInteger, integerToSpanish))
         .testEquals();
   }

   public void testCompositionWildcard() {
     Map<String, Integer> mapJapaneseToInteger = Maps.newHashMap();
     Function<String, Integer> japaneseToInteger =
         Functions.forMap(mapJapaneseToInteger);

     Function<Object, String> numberToSpanish = Functions.constant("Yo no se");

     Function<String, String> japaneseToSpanish =
         Functions.compose(numberToSpanish, japaneseToInteger);
   }

   private static class HashCodeFunction implements Function<Object, Integer> {
     public Integer apply(Object o) {
       return (o == null) ? 0 : o.hashCode();
     }
   }

   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));
   }

   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));
   }

   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(alwaysTrue)
         .addEqualObject(Functions.forPredicate(Predicates.alwaysTrue()))
         .addNotEqualObject(alwaysFalse)
         .addNotEqualObject(Functions.identity())
         .testEquals();

     checkCanReserialize(Functions.forPredicate(Predicates.equalTo(5)));
   }

   public void testConstant() {
     Function<Object, Object> f = Functions.<Object> constant("correct");
     assertEquals("correct", f.apply(new Object()));
     assertEquals("correct", f.apply(null));

     Function<Object, String> g = Functions.constant(null);
     assertEquals(null, g.apply(2));
     assertEquals(null, g.apply(null));

     new EqualsTester(f)
         .addEqualObject(Functions.constant("correct"))
         .addNotEqualObject(Functions.constant("incorrect"))
         .addNotEqualObject(Functions.toStringFunction())
         .addNotEqualObject(g)
         .testEquals();

     new EqualsTester(g)
         .addEqualObject(Functions.constant(null))
         .addNotEqualObject(Functions.constant("incorrect"))
         .addNotEqualObject(Functions.toStringFunction())
         .addNotEqualObject(f)
         .testEquals();

     checkCanReserialize(Functions.constant(5));
   }

   private <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));
     }
   }

   private <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()));
     }
   }

 }
	/*
	* Copyright (C) 2005 Google Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.google.common.base;

	import com.google.common.collect.ImmutableMap;
	import com.google.common.collect.Maps;
	import com.google.common.testutils.EqualsTester;
	import com.google.common.testutils.NullPointerTester;
	import com.google.common.testutils.SerializableTester;

	import junit.framework.TestCase;

	import java.util.Map;

	/**
	* Tests for {@link Functions}.
	*
	* @author Mike Bostock
	* @author Vlad Patryshev
	*/
	public class FunctionsTest extends TestCase {

	public void testIdentity() {
	Function<String, String> identity = Functions.identity();
	assertNull(identity.apply(null));
	assertSame("foo", identity.apply("foo"));
	assertNotSame("foo", identity.apply(new String("foo")));

	checkCanReserializeSingleton(Functions.identity());
	}

	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 e) {
	// expected
	}

	checkCanReserializeSingleton(Functions.toStringFunction());
	}

	public void testNullPointerExceptions() throws Exception {
	NullPointerTester tester = new NullPointerTester();
	tester.testAllPublicStaticMethods(Functions.class);
	}

	public void testForMapWithoutDefault() {
	Map<String, Integer> map = Maps.newHashMap();
	map.put("One", 1);
	map.put("Three", 3);
	Function<String, Integer> function = Functions.forMap(map);

	assertEquals(1, function.apply("One").intValue());
	assertEquals(3, function.apply("Three").intValue());

	try {
	function.apply("Two");
	fail();
	} catch (IllegalArgumentException expected) {
	}

	new EqualsTester(function)
	.addEqualObject(Functions.forMap(map))
	.addEqualObject(Functions.forMap(map))
	.addNotEqualObject(Functions.forMap(map, 42))
	.testEquals();

	checkCanReserialize(Functions.forMap(ImmutableMap.of(1, 2)));
	}

	public void testForMapWithDefault() {
	Map<String, Integer> map = Maps.newHashMap();
	map.put("One", 1);
	map.put("Three", 3);
	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());

	new EqualsTester(function)
	.addEqualObject(Functions.forMap(map, 42))
	.addEqualObject(SerializableTester.reserialize(function))
	.addNotEqualObject(Functions.forMap(map))
	.addNotEqualObject(Functions.forMap(map, null))
	.addNotEqualObject(Functions.forMap(map, 43))
	.testEquals();

	checkCanReserialize(Functions.forMap(ImmutableMap.of(1, 2), 3));
	}

	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(function)
	.addEqualObject(SerializableTester.reserialize(function))
	.addNotEqualObject(Functions.forMap(map, 1))
	.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());
	}

	public void testComposition() {
	Map<String, Integer> mJapaneseToInteger = Maps.newHashMap();
	mJapaneseToInteger.put("Ichi", 1);
	mJapaneseToInteger.put("Ni", 2);
	mJapaneseToInteger.put("San", 3);
	Function<String, Integer> japaneseToInteger =
	Functions.forMap(mJapaneseToInteger);

	Map<Integer, String> mIntegerToSpanish = Maps.newHashMap();
	mIntegerToSpanish.put(1, "Uno");
	mIntegerToSpanish.put(3, "Tres");
	mIntegerToSpanish.put(4, "Cuatro");
	Function<Integer, String> integerToSpanish =
	Functions.forMap(mIntegerToSpanish);

	Function<String, String> japaneseToSpanish =
	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) {
	}

	new EqualsTester(japaneseToSpanish)
	.addEqualObject(
	Functions.compose(integerToSpanish, japaneseToInteger))
	.addEqualObject(
	SerializableTester.reserialize(japaneseToSpanish))
	.addNotEqualObject(japaneseToInteger)
	.addNotEqualObject(integerToSpanish)
	.addNotEqualObject(
	Functions.compose(japaneseToInteger, integerToSpanish))
	.testEquals();
	}

	public void testCompositionWildcard() {
	Map<String, Integer> mapJapaneseToInteger = Maps.newHashMap();
	Function<String, Integer> japaneseToInteger =
	Functions.forMap(mapJapaneseToInteger);

	Function<Object, String> numberToSpanish = Functions.constant("Yo no se");

	Function<String, String> japaneseToSpanish =
	Functions.compose(numberToSpanish, japaneseToInteger);
	}

	private static class HashCodeFunction implements Function<Object, Integer> {
	public Integer apply(Object o) {
	return (o == null) ? 0 : o.hashCode();
	}
	}

	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));
	}

	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));
	}

	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(alwaysTrue)
	.addEqualObject(Functions.forPredicate(Predicates.alwaysTrue()))
	.addNotEqualObject(alwaysFalse)
	.addNotEqualObject(Functions.identity())
	.testEquals();

	checkCanReserialize(Functions.forPredicate(Predicates.equalTo(5)));
	}

	public void testConstant() {
	Function<Object, Object> f = Functions.<Object> constant("correct");
	assertEquals("correct", f.apply(new Object()));
	assertEquals("correct", f.apply(null));

	Function<Object, String> g = Functions.constant(null);
	assertEquals(null, g.apply(2));
	assertEquals(null, g.apply(null));

	new EqualsTester(f)
	.addEqualObject(Functions.constant("correct"))
	.addNotEqualObject(Functions.constant("incorrect"))
	.addNotEqualObject(Functions.toStringFunction())
	.addNotEqualObject(g)
	.testEquals();

	new EqualsTester(g)
	.addEqualObject(Functions.constant(null))
	.addNotEqualObject(Functions.constant("incorrect"))
	.addNotEqualObject(Functions.toStringFunction())
	.addNotEqualObject(f)
	.testEquals();

	checkCanReserialize(Functions.constant(5));
	}

	private <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));
	}
	}

	private <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()));
	}
	}

	}