#intFunnel() and #longFunnel() funnels, and a PrimitiveSink --> OutputStream

wrapper.
-------------
Created by MOE: http://code.google.com/p/moe-java
MOE_MIGRATED_REVID=30307214

Author: cpovirk

guava-tests/pom.xml

@@ -10,7 +10,7 @@
   <artifactId>guava-tests</artifactId>
   <name>Guava Unit Tests</name>
   <description>
-    The unit tests for the Guava libraries - separated into a 
+    The unit tests for the Guava libraries - separated into a
     separate artifact to allow for the testlibs to depend on guava
     itself.
   </description>
@@ -33,6 +33,12 @@
       <version>3.0</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-core</artifactId>
+      <version>1.8.5</version>
+      <scope>test</scope>
+    </dependency>
     <dependency>
       <groupId>org.junit.contrib</groupId>
       <artifactId>truth</artifactId>

guava-tests/test/com/google/common/hash/FunnelsTest.java

@@ -16,12 +16,14 @@
 
 package com.google.common.hash;
 
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
 import com.google.common.hash.AbstractStreamingHashFunction.AbstractStreamingHasher;
 
 import junit.framework.TestCase;
 
-import org.easymock.EasyMock;
-
+import java.io.OutputStream;
 import java.nio.ByteBuffer;
 
 /**
@@ -31,35 +33,45 @@
  */
 public class FunnelsTest extends TestCase {
   public void testForBytes() {
-    PrimitiveSink bytePrimitiveSink = EasyMock.createMock(PrimitiveSink.class);
-
-    EasyMock.expect(bytePrimitiveSink.putBytes(EasyMock.aryEq(new byte[] { 4, 3, 2, 1})))
-        .andReturn(bytePrimitiveSink).once();
-    EasyMock.replay(bytePrimitiveSink);
-
-    Funnels.byteArrayFunnel().funnel(new byte[]{4, 3, 2, 1}, bytePrimitiveSink);
-
-    EasyMock.verify(bytePrimitiveSink);
+    PrimitiveSink bytePrimitiveSink = mock(PrimitiveSink.class);
+    Funnels.byteArrayFunnel().funnel(new byte[] { 4, 3, 2, 1 }, bytePrimitiveSink);
+    verify(bytePrimitiveSink).putBytes(new byte[] { 4, 3, 2, 1 });
   }
 
   public void testForBytes_null() {
     assertNullsThrowException(Funnels.byteArrayFunnel());
   }
 
   public void testForStrings() {
+    PrimitiveSink bytePrimitiveSink = mock(PrimitiveSink.class);
+    Funnels.stringFunnel().funnel("test", bytePrimitiveSink);
+    verify(bytePrimitiveSink).putString("test");
+  }
 
-    PrimitiveSink bytePrimitiveSink = EasyMock.createMock(PrimitiveSink.class);
+  public void testForStrings_null() {
+    assertNullsThrowException(Funnels.stringFunnel());
+  }
 
-    EasyMock.expect(bytePrimitiveSink.putString("test")).andReturn(bytePrimitiveSink).once();
-    EasyMock.replay(bytePrimitiveSink);
+  public void testForInts() {
+    Integer value = 1234;
+    PrimitiveSink bytePrimitiveSink = mock(PrimitiveSink.class);
+    Funnels.integerFunnel().funnel(value, bytePrimitiveSink);
+    verify(bytePrimitiveSink).putInt(1234);
+  }
 
-    Funnels.stringFunnel().funnel("test", bytePrimitiveSink);
+  public void testForInts_null() {
+    assertNullsThrowException(Funnels.integerFunnel());
+  }
 
-    EasyMock.verify(bytePrimitiveSink);
+  public void testForLongs() {
+    Long value = 1234L;
+    PrimitiveSink bytePrimitiveSink = mock(PrimitiveSink.class);
+    Funnels.longFunnel().funnel(value, bytePrimitiveSink);
+    verify(bytePrimitiveSink).putLong(1234);
   }
 
-  public void testForStrings_null() {
-    assertNullsThrowException(Funnels.stringFunnel());
+  public void testForLongs_null() {
+    assertNullsThrowException(Funnels.longFunnel());
   }
 
   private static void assertNullsThrowException(Funnel<?> funnel) {
@@ -77,4 +89,16 @@ private static void assertNullsThrowException(Funnel<?> funnel) {
       fail();
     } catch (NullPointerException ok) {}
   }
+  
+ public void testAsOutputStream() throws Exception {
+   PrimitiveSink sink = mock(PrimitiveSink.class);
+   OutputStream out = Funnels.asOutputStream(sink);
+   byte[] bytes = { 1, 2, 3, 4 };
+   out.write(255);
+   out.write(bytes);
+   out.write(bytes, 1, 2);
+   verify(sink).putByte((byte) 255);
+   verify(sink).putBytes(bytes);
+   verify(sink).putBytes(bytes, 1, 2);
+ }
 }

guava/src/com/google/common/hash/Funnels.java

@@ -15,10 +15,13 @@
 package com.google.common.hash;
 
 import com.google.common.annotations.Beta;
+import com.google.common.base.Preconditions;
+
+import java.io.OutputStream;
 
 /**
  * Funnels for common types. All implementations are serializable.
- * 
+ *
  * @author Dimitris Andreou
  * @since 11.0
  */
@@ -63,4 +66,83 @@ public void funnel(CharSequence from, PrimitiveSink into) {
       return "Funnels.stringFunnel()";
     }
   }
+  
+  /**
+   * Returns a funnel for integers.
+   * 
+   * @since 13.0
+   */
+  public static Funnel<Integer> integerFunnel() {
+    return IntegerFunnel.INSTANCE;
+  }
+  
+  private enum IntegerFunnel implements Funnel<Integer> {
+    INSTANCE;
+    
+    public void funnel(Integer from, PrimitiveSink into) {
+      into.putInt(from);
+    }
+    
+    @Override public String toString() {
+      return "Funnels.integerFunnel()";
+    }
+  }
+
+  /**
+   * Returns a funnel for longs.
+   * 
+   * @since 13.0
+   */
+  public static Funnel<Long> longFunnel() {
+    return LongFunnel.INSTANCE;
+  }
+  
+  private enum LongFunnel implements Funnel<Long> {
+    INSTANCE;
+    
+    public void funnel(Long from, PrimitiveSink into) {
+      into.putLong(from);
+    }
+    
+    @Override public String toString() {
+      return "Funnels.longFunnel()";
+    }
+  }
+  
+  /**
+   * Wraps a {@code PrimitiveSink} as an {@link OutputStream}, so it is easy to
+   * {@link Funnel#funnel funnel} an object to a {@code PrimitiveSink}
+   * if there is already a way to write the contents of the object to an {@code OutputStream}.  
+   * 
+   * <p>The {@code close} and {@code flush} methods of the returned {@code OutputStream}
+   * do nothing, and no method throws {@code IOException}.
+   * 
+   * @since 13.0
+   */
+  public static OutputStream asOutputStream(PrimitiveSink sink) {
+    return new SinkAsStream(sink);
+  }
+  
+  private static class SinkAsStream extends OutputStream {
+    final PrimitiveSink sink;
+    SinkAsStream(PrimitiveSink sink) {
+      this.sink = Preconditions.checkNotNull(sink);
+    }
+    
+    @Override public void write(int b) {
+      sink.putByte((byte) b);
+    }
+
+    @Override public void write(byte[] bytes) {
+      sink.putBytes(bytes);
+    }
+
+    @Override public void write(byte[] bytes, int off, int len) {
+      sink.putBytes(bytes, off, len);
+    }
+    
+    @Override public String toString() {
+      return "Funnels.asOutputStream(" + sink + ")";
+    }
+  }
 }