public class MiscTest { @Test public void multiIteratorTest() { Set<String> a1 = new LinkedHashSet<String>(); a1.add("a"); a1.add("b"); a1.add("c"); Set<String> a2 = new LinkedHashSet<String>(); a2.add("d"); a2.add("e"); a2.add("f"); Iterator<String> mi = Iterators.concat(a1.iterator(), a2.iterator()); assertEquals("a", mi.next()); assertEquals("b", mi.next()); assertEquals("c", mi.next()); assertTrue(mi.hasNext()); assertEquals("d", mi.next()); assertEquals("e", mi.next()); assertEquals("f", mi.next()); assertFalse(mi.hasNext()); } @Test public void arrayBuilderTest() { // Set array builder (no duplicates) ArrayBuilder<String> ab = ArrayBuilder.set(String.class); String[] array = ab.add("a").add("a").add("b").add("c").build(); assertEquals(3, array.length); assertEquals("a", array[0]); assertEquals("b", array[1]); assertEquals("c", array[2]); // List array (duplicates) ab = ArrayBuilder.list(String.class); array = ab.add("a").add("a").add("b").add("c").build(); assertEquals(4, array.length); assertEquals("a", array[0]); assertEquals("a", array[1]); assertEquals("b", array[2]); assertEquals("c", array[3]); } @Test public void chainTest() { final AtomicInteger i = new AtomicInteger(0); ArrayBuilder<Task<String, String>> tasks = ArrayBuilder.list(Task.class); for (int n = 0; n < 10; n++) tasks.add( new Task<String, String>() { public String apply(String input, Chain<String, String> flow) { i.getAndIncrement(); return flow.next(input); } }); Chain<String, String> chain = Chain.<String, String>make() .via(tasks.build()) .to( new Function<String, String>() { public String apply(String input) { i.getAndIncrement(); return input.toUpperCase(Locale.US); } }) .get(); String v = chain.apply("a"); assertEquals("A", v); assertEquals(11, i.get()); } @Test public void comparisonTest() { assertTrue(Comparisons.<String>bothApply(Predicates.<String>notNull()).apply("A", "B")); assertFalse(Comparisons.<String>bothApply(Predicates.<String>notNull()).apply("A", null)); assertFalse(Comparisons.<String>bothApply(Predicates.<String>notNull()).apply(null, "B")); assertTrue(Comparisons.<String>bothAreNull().apply(null, null)); assertFalse(Comparisons.<String>bothAreNull().apply("A", null)); assertFalse(Comparisons.<String>bothAreNull().apply(null, "B")); assertTrue(Comparisons.<String>onlyFirstIsNull().apply(null, "A")); assertFalse(Comparisons.<String>onlyFirstIsNull().apply(null, null)); assertFalse(Comparisons.<String>onlyFirstIsNull().apply("A", null)); assertFalse(Comparisons.<String>onlyFirstIsNull().apply("A", "B")); assertTrue(Comparisons.<String>onlySecondIsNull().apply("A", null)); assertFalse(Comparisons.<String>onlySecondIsNull().apply(null, null)); assertFalse(Comparisons.<String>onlySecondIsNull().apply(null, "B")); assertFalse(Comparisons.<String>onlySecondIsNull().apply("A", "B")); assertTrue(Comparisons.<String>onlyOneIsNull().apply("A", null)); assertFalse(Comparisons.<String>onlyOneIsNull().apply(null, null)); assertTrue(Comparisons.<String>onlyOneIsNull().apply(null, "B")); assertFalse(Comparisons.<String>onlyOneIsNull().apply("A", "B")); assertFalse(Comparisons.<String>neitherIsNull().apply("A", null)); assertFalse(Comparisons.<String>neitherIsNull().apply(null, null)); assertFalse(Comparisons.<String>neitherIsNull().apply(null, "B")); assertTrue(Comparisons.<String>neitherIsNull().apply("A", "B")); assertFalse(Comparisons.eitherApply(Predicates.isNull()).apply("A", "B")); assertTrue(Comparisons.eitherApply(Predicates.isNull()).apply(null, "B")); assertTrue(Comparisons.eitherApply(Predicates.isNull()).apply("A", null)); assertTrue(Comparisons.eitherApply(Predicates.isNull()).apply(null, null)); Comparison<String> equalsIgnoreCase = new Comparison<String>() { public boolean apply(String r1, String r2) { return r1.equalsIgnoreCase(r2); } }; assertTrue(equalsIgnoreCase.apply("A", "a")); Comparison<String> c = Comparisons.<String>neitherIsNull().and(equalsIgnoreCase); assertTrue(c.apply("A", "a")); assertFalse(c.apply(null, "a")); assertFalse(c.apply("a", null)); } @Test public void testMoreFunctions() { // Up first... Choice Function<String, Integer> choice = MoreFunctions.<String, Integer>choice() .of(Comparisons.equalsIgnoreCase().predicateFor("A"), 1) .of(Comparisons.equalsIgnoreCase().predicateFor("B"), 2) .otherwise(3) .get(); assertEquals(Integer.valueOf(1), choice.apply("a")); assertEquals(Integer.valueOf(2), choice.apply("b")); assertEquals(Integer.valueOf(3), choice.apply("c")); // Test createInstance Foo foo = MoreFunctions.createInstance(Foo.class).apply(null); assertNotNull(foo); foo = MoreFunctions.createInstance(Foo.class, String.class).apply(MoreFunctions.array("A")); assertNotNull(foo); assertEquals("A", foo.a()); // Test each String[] array = MoreFunctions.array("a", "b", "c", "d"); array = MoreFunctions.eachArray( new Function<String, String>() { public String apply(String input) { return input.toUpperCase(); } }, String.class) .apply(array); assertEquals("A", array[0]); assertEquals("B", array[1]); assertEquals("C", array[2]); assertEquals("D", array[3]); // Test firstNonNull... assertEquals("A", MoreFunctions.firstNonNull(null, null, null, "A")); // Test futureFunction... executes the function in a separate // thread using the passed in ExecutorService Future<String> future = MoreFunctions.<String, String>futureFunction( new Function<String, String>() { public String apply(String input) { System.out.println("Thread sleeping...."); try { Thread.sleep(10 * 1000); } catch (Throwable t) { } return input; } }, MoreExecutors2.getExitingExecutor()) .apply("A"); try { System.out.println("Waiting for return..."); assertEquals("A", future.get()); } catch (Throwable t) { throw new RuntimeException(t); } } @Test public void testPair() { Pair<String, String> pair = Pair.of("A", "B"); assertEquals("A", pair.first()); assertEquals("B", pair.second()); Map<String, String> map = new HashMap<String, String>(); map.put("A", "B"); map.put("B", "C"); Iterable<Pair<String, String>> pairs = Pair.from(map); assertEquals(2, Iterables.size(pairs)); assertEquals("A", Iterables.get(pairs, 0).first()); assertEquals("B", Iterables.get(pairs, 0).second()); assertEquals("B", Iterables.get(pairs, 1).first()); assertEquals("C", Iterables.get(pairs, 1).second()); } private static final Function< Iterable<Pair<Void, Activity>>, Iterable<Pair<String, Iterable<Integer>>>> f1 = compose(new MyMapper(), MapRed.<String, ASObject>countingReducer()); private static final ReducerFunction<String, Integer, Integer, String> f2 = asFunction(MapRed.<String, Integer>invertReducer(), Collections.<Integer>reverseOrder()); private static final Function< Iterable<Pair<Void, Activity>>, Iterable<Pair<Integer, Iterable<String>>>> f3 = Functions.compose(f2, f1); private static final ExecutorService exec = MoreExecutors2.getExitingExecutor(); private static final Function< Collection<Activity>, Future<Iterable<Pair<Integer, Iterable<String>>>>> ff = Functions.compose( MoreFunctions .<Iterable<Pair<Void, Activity>>, Iterable<Pair<Integer, Iterable<String>>>> futureFunction(f3, exec), Extra.<Activity>pairIndexer()); private Activity getActivity(String name, int n) { return Activity.makeActivity() .actor(PersonObject.makePerson(name)) .id(String.format("urn:%s:%s", name, n)) .get(); } @Test public void testMapRed() throws Exception { Collection<Activity> col = Collection.<Activity>makeCollection() .item(getActivity("Joe", 1)) .item(getActivity("Joe", 2)) .item(getActivity("Mark", 3)) .item(getActivity("Mark", 4)) .item(getActivity("Sally", 5)) .get(); // This is basically MapReduce contained within a Function, // Runs asynch using exiting executorservice... call to // ff.apply(gen).get() hides all the magic... // this particular function looks at the activity stream // and counts the number of activities per actor Iterable<Pair<Integer, Iterable<String>>> ret = ff.apply(col).get(); Pair<Integer, Iterable<String>> first = Iterables.get(ret, 0); Pair<Integer, Iterable<String>> second = Iterables.get(ret, 1); assertEquals(Integer.valueOf(2), first.first()); assertThat(first.second(), hasItems("Joe", "Mark")); assertEquals(Integer.valueOf(1), second.first()); assertThat(second.second(), hasItems("Sally")); } static class MyMapper implements Mapper<Void, Activity, String, ASObject> { public void map(Void key, Activity val, Collector<String, ASObject> context) { String ot = val.getActor().getDisplayName(); context.collect(ot != null ? ot : "", val.getActor()); } } public static class Foo { private final String a; public Foo() { this.a = null; } public Foo(String a) { this.a = a; } public String a() { return a; } } }
@Test public void testMoreFunctions() { // Up first... Choice Function<String, Integer> choice = MoreFunctions.<String, Integer>choice() .of(Comparisons.equalsIgnoreCase().predicateFor("A"), 1) .of(Comparisons.equalsIgnoreCase().predicateFor("B"), 2) .otherwise(3) .get(); assertEquals(Integer.valueOf(1), choice.apply("a")); assertEquals(Integer.valueOf(2), choice.apply("b")); assertEquals(Integer.valueOf(3), choice.apply("c")); // Test createInstance Foo foo = MoreFunctions.createInstance(Foo.class).apply(null); assertNotNull(foo); foo = MoreFunctions.createInstance(Foo.class, String.class).apply(MoreFunctions.array("A")); assertNotNull(foo); assertEquals("A", foo.a()); // Test each String[] array = MoreFunctions.array("a", "b", "c", "d"); array = MoreFunctions.eachArray( new Function<String, String>() { public String apply(String input) { return input.toUpperCase(); } }, String.class) .apply(array); assertEquals("A", array[0]); assertEquals("B", array[1]); assertEquals("C", array[2]); assertEquals("D", array[3]); // Test firstNonNull... assertEquals("A", MoreFunctions.firstNonNull(null, null, null, "A")); // Test futureFunction... executes the function in a separate // thread using the passed in ExecutorService Future<String> future = MoreFunctions.<String, String>futureFunction( new Function<String, String>() { public String apply(String input) { System.out.println("Thread sleeping...."); try { Thread.sleep(10 * 1000); } catch (Throwable t) { } return input; } }, MoreExecutors2.getExitingExecutor()) .apply("A"); try { System.out.println("Waiting for return..."); assertEquals("A", future.get()); } catch (Throwable t) { throw new RuntimeException(t); } }