Test for stuff Guava is missing

Test for stuff guava is missing.

import static com.google.common.base.Functions.identity;
import static com.google.common.base.Optional.presentInstances;
import static com.google.common.collect.Iterables.concat;
import static com.google.common.collect.Iterables.elementsEqual;
import static com.google.common.collect.Iterables.toArray;
import static com.google.common.collect.Lists.newArrayList;
import static java.math.BigDecimal.ONE;
import static java.math.BigDecimal.ZERO;
import static java.util.Arrays.asList;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.Nullable;
import org.junit.Test;
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Ordering;

public class CollectionUtilTest {

  @Test
  public void testSum() throws Exception {
    assertEquals(6, CollectionUtil.sum(asList(1, 2, 3)));
    assertEquals(6, CollectionUtil.sum(asList(3, 2, 1)));
    assertEquals(3, CollectionUtil.sum(asList(3)));
    assertEquals(0, CollectionUtil.sum(Collections.<Integer>emptyList()));
  }

  @Test
  public void testSumOf() throws Exception {
    assertEquals(new BigDecimal("6.0"), CollectionUtil.sumOf(asList(ONE, new BigDecimal("2.5"), new BigDecimal("2.5"))));
    assertEquals(new BigDecimal("6.0"), CollectionUtil.sumOf(asList(ONE, new BigDecimal("3.5"), new BigDecimal("1.5"))));
    assertEquals(new BigDecimal("3"), CollectionUtil.sumOf(asList(new BigDecimal("3"))));
    assertEquals(ZERO, CollectionUtil.sumOf(Collections.<BigDecimal>emptyList()));
  }

  @Test
  public void testElementsEqual() throws Exception {
    Collection<Object> list = new ArrayList<Object>();
    assertTrue(CollectionUtil.allEqual(list));
    list.add("a");
    assertTrue(CollectionUtil.allEqual(list));
    list.add("a");
    assertTrue(CollectionUtil.allEqual(list));
    list.add("b");
    assertFalse(CollectionUtil.allEqual(list));
  }

  @Test
  public void testElementsEqualWithFunction() throws Exception {
    Collection<Object> list = new ArrayList<Object>();
    assertTrue(CollectionUtil.allEqual(list, identity()));
    list.add("a");
    assertTrue(CollectionUtil.allEqual(list, identity()));
    list.add("a");
    assertTrue(CollectionUtil.allEqual(list, identity()));
    list.add("b");
    assertFalse(CollectionUtil.allEqual(list, identity()));
  }

  @Test
  public void testFlatTransform() throws Exception {
    Collection<Iterable<String>> list = new ArrayList<Iterable<String>>();
    list.add(asList("a", "b", "c"));
    list.add(asList("d", "e"));
    list.add(asList("f", "g", "h"));
    Iterable<String> actual = CollectionUtil.flatTransform(list, identityFunction());
    //By definition, flatTransform with identity function is equivalent to concat()
    assertArrayEquals(toArray(concat(list), String.class), toArray(actual, String.class));
  }

  @Test
  public void testAny() throws Exception {
    assertFalse(CollectionUtil.any(newArrayList(), Object.class));
    assertFalse(CollectionUtil.any(newArrayList(), Object.class));

    assertTrue(CollectionUtil.any(newArrayList(new Object()), Object.class));
    assertFalse(CollectionUtil.any(newArrayList(new Object()), String.class));
    assertTrue(CollectionUtil.any(newArrayList(""), Object.class));
  }

  @Test
  public void testCountUnique() throws Exception {
    assertEquals(0, CollectionUtil.countDistinct(Lists.<String>newArrayList(), Ordering.natural()));
    assertEquals(1, CollectionUtil.countDistinct(newArrayList("0"), Ordering.natural()));
    assertEquals(1, CollectionUtil.countDistinct(newArrayList("1"), Ordering.natural()));
    assertEquals(2, CollectionUtil.countDistinct(newArrayList("1", "2"), Ordering.natural()));
    assertEquals(2, CollectionUtil.countDistinct(newArrayList("1", "1", "2"), Ordering.natural()));
    assertEquals(2, CollectionUtil.countDistinct(newArrayList("1", "1", "2", "1"), Ordering.natural()));
    assertEquals(3, CollectionUtil.countDistinct(newArrayList("1", "3", "2", "1"), Ordering.natural()));
  }

  @Test
  public void asOptionalListEmpty() {
    Iterable<Optional<Object>> empty = CollectionUtil.asOptionalList(new ArrayList<Object>());
    assertTrue(Iterables.isEmpty(empty));
  }

  @Test
  public void asOptionalListNonEmpty() {
    List<String> strings = asList("One", "Two", "Three");
    Iterable<Optional<String>> optionalStrings = CollectionUtil.asOptionalList(strings);
    assertTrue(elementsEqual(strings, presentInstances(optionalStrings)));
  }

  @Test
  public void testCombine() throws Exception {
    Map<String, Collection<String>> map1 = new HashMap<String, Collection<String>>();
    map1.put("cars", asList("honda", "ford"));
    map1.put("computers", asList("apple", "dell"));
    map1.put("states", asList("queensland"));

    Map<String, Collection<String>> map2 = new HashMap<String, Collection<String>>();
    map2.put("cars", asList("holden"));
    map2.put("states", asList((String) null));
    map2.put("countries", asList("new zulland"));
    map2.put(null, asList("yikes"));

    Map<String, Collection<String>> combine = CollectionUtil.combine(map1, map2);

    assertArrayEquals(new String[]{"honda", "ford", "holden"}, combine.get("cars").toArray());
    assertArrayEquals(new String[]{"apple", "dell"}, combine.get("computers").toArray());
    assertArrayEquals(new String[]{"queensland", null}, combine.get("states").toArray());
    assertArrayEquals(new String[]{"new zulland"}, combine.get("countries").toArray());
    assertArrayEquals(new String[]{"yikes"}, combine.get(null).toArray());
  }

  /**
   * A function that always returns the same value that was used as its argument.
   */
  private Function<Iterable<String>, Iterable<String>> identityFunction() {
    return new Function<Iterable<String>, Iterable<String>>() {
      @Override
      public Iterable<String> apply(@Nullable Iterable<String> input) {
        return input;
      }
    };
  }

}