HADOOP-19131. Pull in parquet DynMethod tests

If we are going to copy the production classes, let's
take the test methods too.

Change-Id: I86b7af24eb29221469527d48469078f432f46f4e

Author: steveloughran

hadoop-common-project/hadoop-common/src/main/java/org/apache/hadoop/io/wrappedio/WrappedIO.java

@@ -53,6 +53,7 @@
 import static org.apache.hadoop.fs.Options.OpenFileOptions.FS_OPTION_OPENFILE_READ_POLICY;
 import static org.apache.hadoop.fs.statistics.IOStatisticsContext.getCurrentIOStatisticsContext;
 import static org.apache.hadoop.fs.statistics.IOStatisticsSupport.retrieveIOStatistics;
+import static org.apache.hadoop.util.Preconditions.checkArgument;
 
 /**
  * Reflection-friendly access to APIs which are not available in
@@ -64,7 +65,7 @@
  * new classes etc.
  */
 @InterfaceAudience.Public
-@InterfaceStability.Evolving
+@InterfaceStability.Unstable
 public final class WrappedIO {
 
   private WrappedIO() {
@@ -147,7 +148,7 @@ public static boolean pathCapabilities_hasPathCapability(Object fs,
    * @return true iff the object implements StreamCapabilities and the capability is
    * declared available.
    */
-  public static boolean streamCapabilities_hasStreamCapability(Object o, String capability) {
+  public static boolean streamCapabilities_hasCapability(Object o, String capability) {
     if (o instanceof StreamCapabilities) {
       return false;
     }
@@ -205,6 +206,14 @@ public static Path fileSystem_getEnclosingRoot(FileSystem fs, Path path) throws
     return fs.getEnclosingRoot(path);
   }
 
+  /**
+   * Create a new {@link IOStatisticsSnapshot} instance.
+   * @return an empty IOStatisticsSnapshot.
+   */
+  public static Serializable iostatisticsSnapshot_create() {
+    return new IOStatisticsSnapshot();
+  }
+
   /**
    * Extract the IOStatistics from an object in a serializable form.
    * @param source source object, may be null/not a statistics source/instance
@@ -224,7 +233,7 @@ public static Serializable iostatisticsSnapshot_retrieve(@Nullable Object source
    * @return JSON string value or null if source is not an IOStatisticsSnapshot
    * @throws UncheckedIOException Any IO/jackson exception.
    */
-  public static String iostatisticsSnapshot_toJsonString(@Nullable Object snapshot) {
+  public static String iostatisticsSnapshot_toJsonString(@Nullable Serializable snapshot) {
     return applyToIOStatisticsSnapshot(snapshot,
         null,
         IOStatisticsSnapshot.serializer()::toJson);
@@ -241,7 +250,7 @@ public static String iostatisticsSnapshot_toJsonString(@Nullable Object snapshot
    * @throws UncheckedIOException Any IO exception.
    */
   public static boolean iostatisticsSnapshot_save(
-      @Nullable Object snapshot,
+      @Nullable Serializable snapshot,
       FileSystem fs,
       Path path,
       boolean overwrite) {
@@ -251,6 +260,73 @@ public static boolean iostatisticsSnapshot_save(
     });
   }
 
+  /**
+   * Aggregate an existing {@link IOStatisticsSnapshot} with
+   * the supplied statistics.
+   * @param snapshot snapshot to update
+   * @param statistics IOStatistics to add
+   * @return true if the snapshot was updated.
+   * @throws IllegalArgumentException if the {@code statistics} argument is not
+   * null but not an instance of IOStatistics, or if  {@code snapshot} is invalid.
+   */
+  public static boolean iostatisticsSnapshot_aggregate(
+      Serializable snapshot, @Nullable Object statistics) {
+
+    requireIOStatisticsSnapshot(snapshot);
+    if (statistics == null) {
+      return false;
+    }
+    checkArgument(statistics instanceof IOStatistics,
+        "Not an IOStatistics instance: %s", statistics);
+
+    final IOStatistics sourceStats = (IOStatistics) statistics;
+    return applyToIOStatisticsSnapshot(snapshot, false, s ->
+        s.aggregate(sourceStats));
+  }
+
+  /**
+   * Require the parameter to be an instance of {@link IOStatisticsSnapshot}
+   * @param snapshot class to validate
+   * @throws IllegalArgumentException if the condition is not met
+   */
+  private static void requireIOStatisticsSnapshot(final Serializable snapshot) {
+    checkArgument(snapshot instanceof IOStatisticsSnapshot,
+        "Not an IOStatisticsSnapshot %s", snapshot);
+  }
+
+
+  /**
+   * Convert an IOStatisticsSnapshot to a map.
+   * <p>
+   * Counters, gauges, minimums and maximums are all added as key/value pairs.
+   * Mean statistics are added as the sample count, sum of all values and
+   * the mean, which, as it is converted to a long, is only approximate.
+   * It is better to calculate it by retrieving the sum and dividing by the sample
+   * count.
+   * <p>
+   * Mean values have three entries in the map, with the ".mean", ".samples" and ".sum"
+   * suffixes on the base key string.
+   * @param source source of statistics -may be null.
+   * @return a map or null if the source is null/invalid
+   */
+  public static Map<String, Long> iostatisticsSnapshot_toMap(
+      @Nullable Serializable source) {
+
+    return applyToIOStatisticsSnapshot(source, null, stats -> {
+      Map<String, Long> map = new HashMap<>();
+      stats.counters().forEach(map::put);
+      stats.gauges().forEach(map::put);
+      stats.minimums().forEach(map::put);
+      stats.maximums().forEach(map::put);
+      stats.meanStatistics().forEach((k, v) -> {
+        map.put(k + ".mean", (long) v.mean());
+        map.put(k + ".samples", v.getSamples());
+        map.put(k + ".sum", v.getSum());
+      });
+      return map;
+    });
+  }
+
   /**
    * Apply a function to an object which may be an IOStatisticsSnapshot.
    * @param <T> return type
@@ -316,39 +392,10 @@ public static Object iostatisticsSource_demandStringify(
   }
 
   /**
-   * Convert an IOStatistics snapshot to a map.
-   * <p>
-   * Counters, gauges, minimums and maximums are all added as key/value pairs.
-   * Mean statistics are added as the sample count, sum of all values and
-   * the mean, which, as it is converted to a long, is only approximate.
-   * It is better to calculate it by retrieving the sum and dividing by the sample
-   * count.
-   * <p>
-   * Mean values have three entries in the map, with the ".mean", ".samples" and ".sum"
-   * suffixes on the base key string.
-   * @param source source of statistics -may be null.
-   * @return a map or null if the source is null/invalid
-   */
-  public static Map<String, Long> iostatisticsSnapshot_toMap(@Nullable Object source) {
-    return applyToIOStatisticsSnapshot(source, null, stats -> {
-      Map<String, Long> map = new HashMap<>();
-      stats.counters().forEach(map::put);
-      stats.gauges().forEach(map::put);
-      stats.minimums().forEach(map::put);
-      stats.maximums().forEach(map::put);
-      stats.meanStatistics().forEach((k, v) -> {
-        map.put(k + ".mean", (long) v.mean());
-        map.put(k + ".samples", v.getSamples());
-        map.put(k + ".sum", v.getSum());
-      });
-      return map;
-    });
-  }
-
-  /**
-   * Get the context's IOStatisticsContext.
+   * Get the context's {@link IOStatisticsContext} which
+   * implements {@link IOStatisticsSource}.
    * This is either a thread-local value or a global empty context.
-   * @return instance of {@link IOStatisticsContext}
+   * @return instance of {@link IOStatisticsContext}.
    */
   public static Object iostatisticsContext_getCurrent() {
     return getCurrentIOStatisticsContext();
@@ -422,6 +469,6 @@ public static boolean byteBufferPositionedReadable_readFullyAvailable(
     }
     // now rely on the input stream implementing path capabilities, which
     // all the Hadoop FS implementations do.
-    return streamCapabilities_hasStreamCapability(in, StreamCapabilities.PREADBYTEBUFFER);
+    return streamCapabilities_hasCapability(in, StreamCapabilities.PREADBYTEBUFFER);
   }
 }

hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/io/wrappedio/TestWrappedIO.java

@@ -144,7 +144,7 @@ public void testOpenFile() throws Throwable {
     }
     // open with a length and random IO passed in the map
     try (FSDataInputStream s = openFile(path, null, null,
-        (long)len,
+        (long) len,
         map(pair(FS_OPTION_OPENFILE_READ_POLICY, "random")))) {
       s.seek(len - 10);
       s.read();

hadoop-common-project/hadoop-common/src/test/java/org/apache/hadoop/io/wrappedio/impl/Concatenator.java

@@ -0,0 +1,84 @@
+/*
+ *  Licensed to the Apache Software Foundation (ASF) under one
+ *  or more contributor license agreements.  See the NOTICE file
+ *  distributed with this work for additional information
+ *  regarding copyright ownership.  The ASF licenses this file
+ *  to you 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 org.apache.hadoop.io.wrappedio.impl;
+
+/**
+ * This is a class for testing DynMethods and DynConstructors.
+ * Derived from {@code org.apache.parquet.util} test suites.
+ */
+public class Concatenator {
+
+  public static class SomeCheckedException extends Exception {
+  }
+
+  private String sep = "";
+
+  public Concatenator() {
+  }
+
+  public Concatenator(String sep) {
+    this.sep = sep;
+  }
+
+  private Concatenator(char sep) {
+    this.sep = String.valueOf(sep);
+  }
+
+  public Concatenator(Exception e) throws Exception {
+    throw e;
+  }
+
+  public static Concatenator newConcatenator(String sep) {
+    return new Concatenator(sep);
+  }
+
+  private void setSeparator(String sep) {
+    this.sep = sep;
+  }
+
+  public String concat(String left, String right) {
+    return left + sep + right;
+  }
+
+  public String concat(String left, String middle, String right) {
+    return left + sep + middle + sep + right;
+  }
+
+  public String concat(Exception e) throws Exception {
+    throw e;
+  }
+
+  public String concat(String... strings) {
+    if (strings.length >= 1) {
+      StringBuilder sb = new StringBuilder();
+      sb.append(strings[0]);
+      for (int i = 1; i < strings.length; i += 1) {
+        sb.append(sep);
+        sb.append(strings[i]);
+      }
+      return sb.toString();
+    }
+    return null;
+  }
+
+  public static String cat(String... strings) {
+    return new Concatenator().concat(strings);
+  }
+}