parquet-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From b...@apache.org
Subject [1/4] parquet-mr git commit: PARQUET-777: Add Parquet CLI.
Date Fri, 28 Jul 2017 23:25:26 GMT
Repository: parquet-mr
Updated Branches:
  refs/heads/master df9f8d869 -> ddbeb4dd1


http://git-wip-us.apache.org/repos/asf/parquet-mr/blob/ddbeb4dd/parquet-common/src/main/java/org/apache/parquet/util/DynMethods.java
----------------------------------------------------------------------
diff --git a/parquet-common/src/main/java/org/apache/parquet/util/DynMethods.java b/parquet-common/src/main/java/org/apache/parquet/util/DynMethods.java
new file mode 100644
index 0000000..769f31c
--- /dev/null
+++ b/parquet-common/src/main/java/org/apache/parquet/util/DynMethods.java
@@ -0,0 +1,520 @@
+/*
+ * 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.parquet.util;
+
+import org.apache.parquet.Preconditions;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.util.Arrays;
+
+import static org.apache.parquet.Exceptions.throwIfInstance;
+
+public class DynMethods {
+
+  /**
+   * Convenience wrapper class around {@link java.lang.reflect.Method}.
+   *
+   * Allows callers to invoke the wrapped method with all Exceptions wrapped by
+   * RuntimeException, or with a single Exception catch block.
+   */
+  public static class UnboundMethod {
+
+    private final Method method;
+    private final String name;
+    private final int argLength;
+
+    UnboundMethod(Method method, String name) {
+      this.method = method;
+      this.name = name;
+      this.argLength = (method == null || method.isVarArgs()) ? -1 :
+          method.getParameterTypes().length;
+    }
+
+    @SuppressWarnings("unchecked")
+    public <R> R invokeChecked(Object target, Object... args) throws Exception {
+      try {
+        if (argLength < 0) {
+          return (R) method.invoke(target, args);
+        } else {
+          return (R) method.invoke(target, Arrays.copyOfRange(args, 0, argLength));
+        }
+
+      } catch (InvocationTargetException e) {
+        throwIfInstance(e.getCause(), Exception.class);
+        throwIfInstance(e.getCause(), RuntimeException.class);
+        throw new RuntimeException(e.getCause());
+      }
+    }
+
+    public <R> R invoke(Object target, Object... args) {
+      try {
+        return this.<R>invokeChecked(target, args);
+      } catch (Exception e) {
+        throwIfInstance(e, RuntimeException.class);
+        throw new RuntimeException(e);
+      }
+    }
+
+    /**
+     * Returns this method as a BoundMethod for the given receiver.
+     *
+     * @param receiver an Object to receive the method invocation
+     * @return a {@link BoundMethod} for this method and the receiver
+     * @throws IllegalStateException if the method is static
+     * @throws IllegalArgumentException if the receiver's class is incompatible
+     */
+    public BoundMethod bind(Object receiver) {
+      Preconditions.checkState(!isStatic(),
+          "Cannot bind static method " + method.toGenericString());
+      Preconditions.checkArgument(
+          method.getDeclaringClass().isAssignableFrom(receiver.getClass()),
+          "Cannot bind " + method.toGenericString() + " to instance of " +
+              receiver.getClass());
+
+      return new BoundMethod(this, receiver);
+    }
+
+    /**
+     * @return whether the method is a static method
+     */
+    public boolean isStatic() {
+      return Modifier.isStatic(method.getModifiers());
+    }
+
+    /**
+     * @return whether the method is a noop
+     */
+    public boolean isNoop() {
+      return this == NOOP;
+    }
+
+    /**
+     * Returns this method as a StaticMethod.
+     *
+     * @return a {@link StaticMethod} for this method
+     * @throws IllegalStateException if the method is not static
+     */
+    public StaticMethod asStatic() {
+      Preconditions.checkState(isStatic(), "Method is not static");
+      return new StaticMethod(this);
+    }
+
+    public String toString() {
+      return "DynMethods.UnboundMethod(name=" + name +" method=" +
+          method.toGenericString() + ")";
+    }
+
+    /**
+     * Singleton {@link UnboundMethod}, performs no operation and returns null.
+     */
+    private static UnboundMethod NOOP = new UnboundMethod(null, "NOOP") {
+      @Override
+      public <R> R invokeChecked(Object target, Object... args) throws Exception {
+        return null;
+      }
+
+      @Override
+      public BoundMethod bind(Object receiver) {
+        return new BoundMethod(this, receiver);
+      }
+
+      @Override
+      public StaticMethod asStatic() {
+        return new StaticMethod(this);
+      }
+
+      @Override
+      public boolean isStatic() {
+        return true;
+      }
+
+      @Override
+      public String toString() {
+        return "DynMethods.UnboundMethod(NOOP)";
+      }
+    };
+  }
+
+  public static class BoundMethod {
+    private final UnboundMethod method;
+    private final Object receiver;
+
+    private BoundMethod(UnboundMethod method, Object receiver) {
+      this.method = method;
+      this.receiver = receiver;
+    }
+
+    public <R> R invokeChecked(Object... args) throws Exception {
+      return method.invokeChecked(receiver, args);
+    }
+
+    public <R> R invoke(Object... args) {
+      return method.invoke(receiver, args);
+    }
+  }
+
+  public static class StaticMethod {
+    private final UnboundMethod method;
+
+    private StaticMethod(UnboundMethod method) {
+      this.method = method;
+    }
+
+    public <R> R invokeChecked(Object... args) throws Exception {
+      return method.invokeChecked(null, args);
+    }
+
+    public <R> R invoke(Object... args) {
+      return method.invoke(null, args);
+    }
+  }
+
+  public static class Builder {
+    private final String name;
+    private ClassLoader loader = Thread.currentThread().getContextClassLoader();
+    private UnboundMethod method = null;
+
+    public Builder(String methodName) {
+      this.name = methodName;
+    }
+
+    /**
+     * Set the {@link ClassLoader} used to lookup classes by name.
+     * <p>
+     * If not set, the current thread's ClassLoader is used.
+     *
+     * @param loader a ClassLoader
+     * @return this Builder for method chaining
+     */
+    public Builder loader(ClassLoader loader) {
+      this.loader = loader;
+      return this;
+    }
+
+    /**
+     * If no implementation has been found, adds a NOOP method.
+     *
+     * Note: calls to impl will not match after this method is called!
+     *
+     * @return this Builder for method chaining
+     */
+    public Builder orNoop() {
+      if (method == null) {
+        this.method = UnboundMethod.NOOP;
+      }
+      return this;
+    }
+
+    /**
+     * Checks for an implementation, first finding the given class by name.
+     *
+     * @param className name of a class
+     * @param methodName name of a method (different from constructor)
+     * @param argClasses argument classes for the method
+     * @return this Builder for method chaining
+     * @see {@link java.lang.Class#forName(String)}
+     * @see {@link java.lang.Class#getMethod(String, Class[])}
+     */
+    public Builder impl(String className, String methodName, Class<?>... argClasses)
{
+      // don't do any work if an implementation has been found
+      if (method != null) {
+        return this;
+      }
+
+      try {
+        Class<?> targetClass = Class.forName(className, true, loader);
+        impl(targetClass, methodName, argClasses);
+      } catch (ClassNotFoundException e) {
+        // not the right implementation
+      }
+      return this;
+    }
+
+    /**
+     * Checks for an implementation, first finding the given class by name.
+     *
+     * The name passed to the constructor is the method name used.
+     *
+     * @param className name of a class
+     * @param argClasses argument classes for the method
+     * @return this Builder for method chaining
+     * @see {@link java.lang.Class#forName(String)}
+     * @see {@link java.lang.Class#getMethod(String, Class[])}
+     */
+    public Builder impl(String className, Class<?>... argClasses) {
+      impl(className, name, argClasses);
+      return this;
+    }
+
+    /**
+     * Checks for a method implementation.
+     *
+     * @param methodName name of a method (different from constructor)
+     * @param argClasses argument classes for the method
+     * @return this Builder for method chaining
+     * @see {@link java.lang.Class#forName(String)}
+     * @see {@link java.lang.Class#getMethod(String, Class[])}
+     */
+    public Builder impl(Class<?> targetClass, String methodName, Class<?>...
argClasses) {
+      // don't do any work if an implementation has been found
+      if (method != null) {
+        return this;
+      }
+
+      try {
+        this.method = new UnboundMethod(
+            targetClass.getMethod(methodName, argClasses), name);
+      } catch (NoSuchMethodException e) {
+        // not the right implementation
+      }
+      return this;
+    }
+
+    /**
+     * Checks for a method implementation.
+     *
+     * The name passed to the constructor is the method name used.
+     *
+     * @param argClasses argument classes for the method
+     * @return this Builder for method chaining
+     * @see {@link java.lang.Class#forName(String)}
+     * @see {@link java.lang.Class#getMethod(String, Class[])}
+     */
+    public Builder impl(Class<?> targetClass, Class<?>... argClasses) {
+      impl(targetClass, name, argClasses);
+      return this;
+    }
+
+    public Builder ctorImpl(Class<?> targetClass, Class<?>... argClasses) {
+      // don't do any work if an implementation has been found
+      if (method != null) {
+        return this;
+      }
+
+      try {
+        this.method = new DynConstructors.Builder()
+            .impl(targetClass, argClasses)
+            .buildChecked();
+      } catch (NoSuchMethodException e) {
+        // not the right implementation
+      }
+      return this;
+    }
+
+    public Builder ctorImpl(String className, Class<?>... argClasses) {
+      // don't do any work if an implementation has been found
+      if (method != null) {
+        return this;
+      }
+
+      try {
+        this.method = new DynConstructors.Builder()
+            .impl(className, argClasses)
+            .buildChecked();
+      } catch (NoSuchMethodException e) {
+        // not the right implementation
+      }
+      return this;
+    }
+
+    /**
+     * Checks for an implementation, first finding the given class by name.
+     *
+     * @param className name of a class
+     * @param methodName name of a method (different from constructor)
+     * @param argClasses argument classes for the method
+     * @return this Builder for method chaining
+     * @see {@link java.lang.Class#forName(String)}
+     * @see {@link java.lang.Class#getMethod(String, Class[])}
+     */
+    public Builder hiddenImpl(String className, String methodName, Class<?>... argClasses)
{
+      // don't do any work if an implementation has been found
+      if (method != null) {
+        return this;
+      }
+
+      try {
+        Class<?> targetClass = Class.forName(className, true, loader);
+        hiddenImpl(targetClass, methodName, argClasses);
+      } catch (ClassNotFoundException e) {
+        // not the right implementation
+      }
+      return this;
+    }
+
+    /**
+     * Checks for an implementation, first finding the given class by name.
+     *
+     * The name passed to the constructor is the method name used.
+     *
+     * @param className name of a class
+     * @param argClasses argument classes for the method
+     * @return this Builder for method chaining
+     * @see {@link java.lang.Class#forName(String)}
+     * @see {@link java.lang.Class#getMethod(String, Class[])}
+     */
+    public Builder hiddenImpl(String className, Class<?>... argClasses) {
+      hiddenImpl(className, name, argClasses);
+      return this;
+    }
+
+    /**
+     * Checks for a method implementation.
+     *
+     * @param methodName name of a method (different from constructor)
+     * @param argClasses argument classes for the method
+     * @return this Builder for method chaining
+     * @see {@link java.lang.Class#forName(String)}
+     * @see {@link java.lang.Class#getMethod(String, Class[])}
+     */
+    public Builder hiddenImpl(Class<?> targetClass, String methodName, Class<?>...
argClasses) {
+      // don't do any work if an implementation has been found
+      if (method != null) {
+        return this;
+      }
+
+      try {
+        Method hidden = targetClass.getDeclaredMethod(methodName, argClasses);
+        AccessController.doPrivileged(new MakeAccessible(hidden));
+        this.method = new UnboundMethod(hidden, name);
+      } catch (SecurityException e) {
+        // unusable
+      } catch (NoSuchMethodException e) {
+        // not the right implementation
+      }
+      return this;
+    }
+
+    /**
+     * Checks for a method implementation.
+     *
+     * The name passed to the constructor is the method name used.
+     *
+     * @param argClasses argument classes for the method
+     * @return this Builder for method chaining
+     * @see {@link java.lang.Class#forName(String)}
+     * @see {@link java.lang.Class#getMethod(String, Class[])}
+     */
+    public Builder hiddenImpl(Class<?> targetClass, Class<?>... argClasses) {
+      hiddenImpl(targetClass, name, argClasses);
+      return this;
+    }
+
+    /**
+     * Returns the first valid implementation as a UnboundMethod or throws a
+     * NoSuchMethodException if there is none.
+     *
+     * @return a {@link UnboundMethod} with a valid implementation
+     * @throws NoSuchMethodException if no implementation was found
+     */
+    public UnboundMethod buildChecked() throws NoSuchMethodException {
+      if (method != null) {
+        return method;
+      } else {
+        throw new NoSuchMethodException("Cannot find method: " + name);
+      }
+    }
+
+    /**
+     * Returns the first valid implementation as a UnboundMethod or throws a
+     * RuntimeError if there is none.
+     *
+     * @return a {@link UnboundMethod} with a valid implementation
+     * @throws RuntimeException if no implementation was found
+     */
+    public UnboundMethod build() {
+      if (method != null) {
+        return method;
+      } else {
+        throw new RuntimeException("Cannot find method: " + name);
+      }
+    }
+
+    /**
+     * Returns the first valid implementation as a BoundMethod or throws a
+     * NoSuchMethodException if there is none.
+     *
+     * @param receiver an Object to receive the method invocation
+     * @return a {@link BoundMethod} with a valid implementation and receiver
+     * @throws IllegalStateException if the method is static
+     * @throws IllegalArgumentException if the receiver's class is incompatible
+     * @throws NoSuchMethodException if no implementation was found
+     */
+    public BoundMethod buildChecked(Object receiver) throws NoSuchMethodException {
+      return buildChecked().bind(receiver);
+    }
+
+    /**
+     * Returns the first valid implementation as a BoundMethod or throws a
+     * RuntimeError if there is none.
+     *
+     * @param receiver an Object to receive the method invocation
+     * @return a {@link BoundMethod} with a valid implementation and receiver
+     * @throws IllegalStateException if the method is static
+     * @throws IllegalArgumentException if the receiver's class is incompatible
+     * @throws RuntimeException if no implementation was found
+     */
+    public BoundMethod build(Object receiver) {
+      return build().bind(receiver);
+    }
+
+    /**
+     * Returns the first valid implementation as a StaticMethod or throws a
+     * NoSuchMethodException if there is none.
+     *
+     * @return a {@link StaticMethod} with a valid implementation
+     * @throws IllegalStateException if the method is not static
+     * @throws NoSuchMethodException if no implementation was found
+     */
+    public StaticMethod buildStaticChecked() throws NoSuchMethodException {
+      return buildChecked().asStatic();
+    }
+
+    /**
+     * Returns the first valid implementation as a StaticMethod or throws a
+     * RuntimeException if there is none.
+     *
+     * @return a {@link StaticMethod} with a valid implementation
+     * @throws IllegalStateException if the method is not static
+     * @throws RuntimeException if no implementation was found
+     */
+    public StaticMethod buildStatic() {
+      return build().asStatic();
+    }
+
+  }
+
+  private static class MakeAccessible implements PrivilegedAction<Void> {
+    private Method hidden;
+
+    public MakeAccessible(Method hidden) {
+      this.hidden = hidden;
+    }
+
+    @Override
+    public Void run() {
+      hidden.setAccessible(true);
+      return null;
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/parquet-mr/blob/ddbeb4dd/parquet-common/src/test/java/org/apache/parquet/TestUtils.java
----------------------------------------------------------------------
diff --git a/parquet-common/src/test/java/org/apache/parquet/TestUtils.java b/parquet-common/src/test/java/org/apache/parquet/TestUtils.java
new file mode 100644
index 0000000..2062827
--- /dev/null
+++ b/parquet-common/src/test/java/org/apache/parquet/TestUtils.java
@@ -0,0 +1,70 @@
+/*
+ *  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.parquet;
+
+import org.junit.Assert;
+import java.util.concurrent.Callable;
+
+public class TestUtils {
+
+  /**
+   * A convenience method to avoid a large number of @Test(expected=...) tests
+   * @param message A String message to describe this assertion
+   * @param expected An Exception class that the Runnable should throw
+   * @param callable A Callable that is expected to throw the exception
+   */
+  public static void assertThrows(
+      String message, Class<? extends Exception> expected, Callable callable) {
+    try {
+      callable.call();
+      Assert.fail("No exception was thrown (" + message + "), expected: " +
+          expected.getName());
+    } catch (Exception actual) {
+      try {
+        Assert.assertEquals(message, expected, actual.getClass());
+      } catch (AssertionError e) {
+        e.addSuppressed(actual);
+        throw e;
+      }
+    }
+  }
+
+  /**
+   * A convenience method to avoid a large number of @Test(expected=...) tests
+   * @param message A String message to describe this assertion
+   * @param expected An Exception class that the Runnable should throw
+   * @param runnable A Runnable that is expected to throw the runtime exception
+   */
+  public static void assertThrows(
+      String message, Class<? extends Exception> expected, Runnable runnable) {
+    try {
+      runnable.run();
+      Assert.fail("No exception was thrown (" + message + "), expected: " +
+          expected.getName());
+    } catch (Exception actual) {
+      try {
+        Assert.assertEquals(message, expected, actual.getClass());
+      } catch (AssertionError e) {
+        e.addSuppressed(actual);
+        throw e;
+      }
+    }
+  }
+}

http://git-wip-us.apache.org/repos/asf/parquet-mr/blob/ddbeb4dd/parquet-common/src/test/java/org/apache/parquet/util/Concatenator.java
----------------------------------------------------------------------
diff --git a/parquet-common/src/test/java/org/apache/parquet/util/Concatenator.java b/parquet-common/src/test/java/org/apache/parquet/util/Concatenator.java
new file mode 100644
index 0000000..261c2be
--- /dev/null
+++ b/parquet-common/src/test/java/org/apache/parquet/util/Concatenator.java
@@ -0,0 +1,82 @@
+/*
+ *  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.parquet.util;
+
+/**
+ * This is a class for testing DynMethods and DynConstructors.
+ */
+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);
+  }
+}

http://git-wip-us.apache.org/repos/asf/parquet-mr/blob/ddbeb4dd/parquet-common/src/test/java/org/apache/parquet/util/TestDynConstructors.java
----------------------------------------------------------------------
diff --git a/parquet-common/src/test/java/org/apache/parquet/util/TestDynConstructors.java
b/parquet-common/src/test/java/org/apache/parquet/util/TestDynConstructors.java
new file mode 100644
index 0000000..1ab9582
--- /dev/null
+++ b/parquet-common/src/test/java/org/apache/parquet/util/TestDynConstructors.java
@@ -0,0 +1,235 @@
+/*
+ *  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.parquet.util;
+
+import org.apache.parquet.TestUtils;
+import org.apache.parquet.util.Concatenator.SomeCheckedException;
+import org.junit.Assert;
+import org.junit.Test;
+import java.util.concurrent.Callable;
+
+public class TestDynConstructors {
+  @Test
+  public void testNoImplCall() {
+    final DynConstructors.Builder builder = new DynConstructors.Builder();
+
+    TestUtils.assertThrows("Checked build should throw NoSuchMethodException",
+        NoSuchMethodException.class, new Callable() {
+          @Override
+          public Object call() throws NoSuchMethodException {
+            return builder.buildChecked();
+          }
+        });
+
+    TestUtils.assertThrows("Normal build should throw RuntimeException",
+        RuntimeException.class, new Runnable() {
+          @Override
+          public void run() {
+            builder.build();
+          }
+        });
+  }
+
+  @Test
+  public void testMissingClass() {
+    final DynConstructors.Builder builder = new DynConstructors.Builder()
+        .impl("not.a.RealClass");
+
+    TestUtils.assertThrows("Checked build should throw NoSuchMethodException",
+        NoSuchMethodException.class, new Callable() {
+          @Override
+          public Object call() throws NoSuchMethodException {
+            return builder.buildChecked();
+          }
+        });
+
+    TestUtils.assertThrows("Normal build should throw RuntimeException",
+        RuntimeException.class, new Runnable() {
+          @Override
+          public void run() {
+            builder.build();
+          }
+        });
+  }
+
+  @Test
+  public void testMissingConstructor() {
+    final DynConstructors.Builder builder = new DynConstructors.Builder()
+        .impl(Concatenator.class, String.class, String.class);
+
+    TestUtils.assertThrows("Checked build should throw NoSuchMethodException",
+        NoSuchMethodException.class, new Callable() {
+          @Override
+          public Object call() throws NoSuchMethodException {
+            return builder.buildChecked();
+          }
+        });
+
+    TestUtils.assertThrows("Normal build should throw RuntimeException",
+        RuntimeException.class, new Runnable() {
+          @Override
+          public void run() {
+            builder.build();
+          }
+        });
+  }
+
+  @Test
+  public void testFirstImplReturned() throws Exception {
+    final DynConstructors.Ctor<Concatenator> sepCtor = new DynConstructors.Builder()
+        .impl("not.a.RealClass", String.class)
+        .impl(Concatenator.class, String.class)
+        .impl(Concatenator.class)
+        .buildChecked();
+
+    Concatenator dashCat = sepCtor.newInstanceChecked("-");
+    Assert.assertEquals("Should construct with the 1-arg version",
+        "a-b", dashCat.concat("a", "b"));
+
+    TestUtils.assertThrows("Should complain about extra arguments",
+        IllegalArgumentException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return sepCtor.newInstanceChecked("/", "-");
+          }
+        });
+
+    TestUtils.assertThrows("Should complain about extra arguments",
+        IllegalArgumentException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return sepCtor.newInstance("/", "-");
+          }
+        });
+
+    DynConstructors.Ctor<Concatenator> defaultCtor = new DynConstructors.Builder()
+        .impl("not.a.RealClass", String.class)
+        .impl(Concatenator.class)
+        .impl(Concatenator.class, String.class)
+        .buildChecked();
+
+    Concatenator cat = defaultCtor.newInstanceChecked();
+    Assert.assertEquals("Should construct with the no-arg version",
+        "ab", cat.concat("a", "b"));
+  }
+
+  @Test
+  public void testExceptionThrown() throws Exception {
+    final SomeCheckedException exc = new SomeCheckedException();
+    final DynConstructors.Ctor<Concatenator> sepCtor = new DynConstructors.Builder()
+        .impl("not.a.RealClass", String.class)
+        .impl(Concatenator.class, Exception.class)
+        .buildChecked();
+
+    TestUtils.assertThrows("Should re-throw the exception",
+        SomeCheckedException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return sepCtor.newInstanceChecked(exc);
+          }
+        });
+
+    TestUtils.assertThrows("Should wrap the exception in RuntimeException",
+        RuntimeException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return sepCtor.newInstance(exc);
+          }
+        });
+  }
+
+  @Test
+  public void testStringClassname() throws Exception {
+    final DynConstructors.Ctor<Concatenator> sepCtor = new DynConstructors.Builder()
+        .impl(Concatenator.class.getName(), String.class)
+        .buildChecked();
+
+    Assert.assertNotNull("Should find 1-arg constructor", sepCtor.newInstance("-"));
+  }
+
+  @Test
+  public void testHiddenMethod() throws Exception {
+    TestUtils.assertThrows("Should fail to find hidden method",
+        NoSuchMethodException.class, new Callable() {
+          @Override
+          public Object call() throws NoSuchMethodException {
+            return new DynMethods.Builder("setSeparator")
+                .impl(Concatenator.class, char.class)
+                .buildChecked();
+          }
+        });
+
+    final DynConstructors.Ctor<Concatenator> sepCtor = new DynConstructors.Builder()
+        .hiddenImpl(Concatenator.class.getName(), char.class)
+        .buildChecked();
+
+    Assert.assertNotNull("Should find hidden ctor with hiddenImpl", sepCtor);
+
+    Concatenator slashCat = sepCtor.newInstanceChecked('/');
+
+    Assert.assertEquals("Should use separator /",
+        "a/b", slashCat.concat("a", "b"));
+  }
+
+  @Test
+  public void testBind() throws Exception {
+    final DynConstructors.Ctor<Concatenator> ctor = new DynConstructors.Builder()
+        .impl(Concatenator.class.getName())
+        .buildChecked();
+
+    Assert.assertTrue("Should always be static", ctor.isStatic());
+
+    TestUtils.assertThrows("Should complain that method is static",
+        IllegalStateException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return ctor.bind(null);
+          }
+        });
+  }
+
+  @Test
+  public void testInvoke() throws Exception {
+    final DynMethods.UnboundMethod ctor = new DynConstructors.Builder()
+        .impl(Concatenator.class.getName())
+        .buildChecked();
+
+    TestUtils.assertThrows("Should complain that target must be null",
+        IllegalArgumentException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return ctor.invokeChecked("a");
+          }
+        });
+
+    TestUtils.assertThrows("Should complain that target must be null",
+        IllegalArgumentException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return ctor.invoke("a");
+          }
+        });
+
+    Assert.assertNotNull("Should allow invokeChecked(null, ...)",
+        ctor.invokeChecked(null));
+    Assert.assertNotNull("Should allow invoke(null, ...)",
+        ctor.invoke(null));
+  }
+}

http://git-wip-us.apache.org/repos/asf/parquet-mr/blob/ddbeb4dd/parquet-common/src/test/java/org/apache/parquet/util/TestDynMethods.java
----------------------------------------------------------------------
diff --git a/parquet-common/src/test/java/org/apache/parquet/util/TestDynMethods.java b/parquet-common/src/test/java/org/apache/parquet/util/TestDynMethods.java
new file mode 100644
index 0000000..7017c67
--- /dev/null
+++ b/parquet-common/src/test/java/org/apache/parquet/util/TestDynMethods.java
@@ -0,0 +1,410 @@
+/*
+ *  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.parquet.util;
+
+import org.apache.parquet.TestUtils;
+import org.apache.parquet.util.Concatenator.SomeCheckedException;
+import org.junit.Assert;
+import org.junit.Test;
+import java.util.concurrent.Callable;
+
+public class TestDynMethods {
+  @Test
+  public void testNoImplCall() {
+    final DynMethods.Builder builder = new DynMethods.Builder("concat");
+
+    TestUtils.assertThrows("Checked build should throw NoSuchMethodException",
+        NoSuchMethodException.class, new Callable() {
+          @Override
+          public Object call() throws NoSuchMethodException {
+            return builder.buildChecked();
+          }
+        });
+
+    TestUtils.assertThrows("Normal build should throw RuntimeException",
+        RuntimeException.class, new Runnable() {
+          @Override
+          public void run() {
+            builder.build();
+          }
+        });
+  }
+
+  @Test
+  public void testMissingClass() {
+    final DynMethods.Builder builder = new DynMethods.Builder("concat")
+        .impl("not.a.RealClass", String.class, String.class);
+
+    TestUtils.assertThrows("Checked build should throw NoSuchMethodException",
+        NoSuchMethodException.class, new Callable() {
+          @Override
+          public Object call() throws NoSuchMethodException {
+            return builder.buildChecked();
+          }
+        });
+
+    TestUtils.assertThrows("Normal build should throw RuntimeException",
+        RuntimeException.class, new Runnable() {
+          @Override
+          public void run() {
+            builder.build();
+          }
+        });
+  }
+
+  @Test
+  public void testMissingMethod() {
+    final DynMethods.Builder builder = new DynMethods.Builder("concat")
+        .impl(Concatenator.class, "cat2strings", String.class, String.class);
+
+    TestUtils.assertThrows("Checked build should throw NoSuchMethodException",
+        NoSuchMethodException.class, new Callable() {
+          @Override
+          public Object call() throws NoSuchMethodException {
+            return builder.buildChecked();
+          }
+        });
+
+    TestUtils.assertThrows("Normal build should throw RuntimeException",
+        RuntimeException.class, new Runnable() {
+          @Override
+          public void run() {
+            builder.build();
+          }
+        });
+  }
+
+  @Test
+  public void testFirstImplReturned() throws Exception {
+    Concatenator obj = new Concatenator("-");
+    DynMethods.UnboundMethod cat2 = new DynMethods.Builder("concat")
+        .impl("not.a.RealClass", String.class, String.class)
+        .impl(Concatenator.class, String.class, String.class)
+        .impl(Concatenator.class, String.class, String.class, String.class)
+        .buildChecked();
+
+    Assert.assertEquals("Should call the 2-arg version successfully",
+        "a-b", cat2.invoke(obj, "a", "b"));
+
+    Assert.assertEquals("Should ignore extra arguments",
+        "a-b", cat2.invoke(obj, "a", "b", "c"));
+
+    DynMethods.UnboundMethod cat3 = new DynMethods.Builder("concat")
+        .impl("not.a.RealClass", String.class, String.class)
+        .impl(Concatenator.class, String.class, String.class, String.class)
+        .impl(Concatenator.class, String.class, String.class)
+        .build();
+
+    Assert.assertEquals("Should call the 3-arg version successfully",
+        "a-b-c", cat3.invoke(obj, "a", "b", "c"));
+
+    Assert.assertEquals("Should call the 3-arg version null padding",
+        "a-b-null", cat3.invoke(obj, "a", "b"));
+  }
+
+  @Test
+  public void testVarArgs() throws Exception {
+    DynMethods.UnboundMethod cat = new DynMethods.Builder("concat")
+        .impl(Concatenator.class, String[].class)
+        .buildChecked();
+
+    Assert.assertEquals("Should use the varargs version", "abcde",
+        cat.invokeChecked(
+            new Concatenator(),
+            (Object) new String[] {"a", "b", "c", "d", "e"}));
+
+    Assert.assertEquals("Should use the varargs version", "abcde",
+        cat.bind(new Concatenator())
+            .invokeChecked((Object) new String[] {"a", "b", "c", "d", "e"}));
+  }
+
+  @Test
+  public void testIncorrectArguments() throws Exception {
+    final Concatenator obj = new Concatenator("-");
+    final DynMethods.UnboundMethod cat = new DynMethods.Builder("concat")
+        .impl("not.a.RealClass", String.class, String.class)
+        .impl(Concatenator.class, String.class, String.class)
+        .buildChecked();
+
+    TestUtils.assertThrows("Should fail if non-string arguments are passed",
+        IllegalArgumentException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return cat.invoke(obj, 3, 4);
+          }
+        });
+
+    TestUtils.assertThrows("Should fail if non-string arguments are passed",
+        IllegalArgumentException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return cat.invokeChecked(obj, 3, 4);
+          }
+        });
+  }
+
+  @Test
+  public void testExceptionThrown() throws Exception {
+    final SomeCheckedException exc = new SomeCheckedException();
+    final Concatenator obj = new Concatenator("-");
+    final DynMethods.UnboundMethod cat = new DynMethods.Builder("concat")
+        .impl("not.a.RealClass", String.class, String.class)
+        .impl(Concatenator.class, Exception.class)
+        .buildChecked();
+
+    TestUtils.assertThrows("Should re-throw the exception",
+        SomeCheckedException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return cat.invokeChecked(obj, exc);
+          }
+        });
+
+    TestUtils.assertThrows("Should wrap the exception in RuntimeException",
+        RuntimeException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return cat.invoke(obj, exc);
+          }
+        });
+  }
+
+  @Test
+  public void testNameChange() throws Exception {
+    Concatenator obj = new Concatenator("-");
+    DynMethods.UnboundMethod cat = new DynMethods.Builder("cat")
+        .impl(Concatenator.class, "concat", String.class, String.class)
+        .buildChecked();
+
+    Assert.assertEquals("Should find 2-arg concat method",
+        "a-b", cat.invoke(obj, "a", "b"));
+  }
+
+  @Test
+  public void testStringClassname() throws Exception {
+    Concatenator obj = new Concatenator("-");
+    DynMethods.UnboundMethod cat = new DynMethods.Builder("concat")
+        .impl(Concatenator.class.getName(), String.class, String.class)
+        .buildChecked();
+
+    Assert.assertEquals("Should find 2-arg concat method",
+        "a-b", cat.invoke(obj, "a", "b"));
+  }
+
+  @Test
+  public void testHiddenMethod() throws Exception {
+    Concatenator obj = new Concatenator("-");
+
+    TestUtils.assertThrows("Should fail to find hidden method",
+        NoSuchMethodException.class, new Callable() {
+          @Override
+          public Object call() throws NoSuchMethodException {
+            return new DynMethods.Builder("setSeparator")
+                .impl(Concatenator.class, String.class)
+                .buildChecked();
+          }
+        });
+
+    DynMethods.UnboundMethod changeSep = new DynMethods.Builder("setSeparator")
+        .hiddenImpl(Concatenator.class, String.class)
+        .buildChecked();
+
+    Assert.assertNotNull("Should find hidden method with hiddenImpl",
+        changeSep);
+
+    changeSep.invokeChecked(obj, "/");
+
+    Assert.assertEquals("Should use separator / instead of -",
+        "a/b", obj.concat("a", "b"));
+  }
+
+  @Test
+  public void testBoundMethod() throws Exception {
+    DynMethods.UnboundMethod cat = new DynMethods.Builder("concat")
+        .impl(Concatenator.class, String.class, String.class)
+        .buildChecked();
+
+    // Unbound methods can be bound multiple times
+    DynMethods.BoundMethod dashCat = cat.bind(new Concatenator("-"));
+    DynMethods.BoundMethod underCat = cat.bind(new Concatenator("_"));
+
+    Assert.assertEquals("Should use '-' object without passing",
+        "a-b", dashCat.invoke("a", "b"));
+    Assert.assertEquals("Should use '_' object without passing",
+        "a_b", underCat.invoke("a", "b"));
+
+    DynMethods.BoundMethod slashCat = new DynMethods.Builder("concat")
+        .impl(Concatenator.class, String.class, String.class)
+        .buildChecked(new Concatenator("/"));
+
+    Assert.assertEquals("Should use bound object from builder without passing",
+        "a/b", slashCat.invoke("a", "b"));
+  }
+
+  @Test
+  public void testBindStaticMethod() throws Exception {
+    final DynMethods.Builder builder = new DynMethods.Builder("cat")
+        .impl(Concatenator.class, String[].class);
+
+    TestUtils.assertThrows("Should complain that method is static",
+        IllegalStateException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return builder.buildChecked(new Concatenator());
+          }
+        });
+
+    TestUtils.assertThrows("Should complain that method is static",
+        IllegalStateException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return builder.build(new Concatenator());
+          }
+        });
+
+    final DynMethods.UnboundMethod staticCat = builder.buildChecked();
+    Assert.assertTrue("Should be static", staticCat.isStatic());
+
+    TestUtils.assertThrows("Should complain that method is static",
+        IllegalStateException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return staticCat.bind(new Concatenator());
+          }
+        });
+  }
+
+  @Test
+  public void testStaticMethod() throws Exception {
+    DynMethods.StaticMethod staticCat = new DynMethods.Builder("cat")
+        .impl(Concatenator.class, String[].class)
+        .buildStaticChecked();
+
+    Assert.assertEquals("Should call varargs static method cat(String...)",
+        "abcde", staticCat.invokeChecked(
+            (Object) new String[] {"a", "b", "c", "d", "e"}));
+  }
+
+  @Test
+  public void testNonStaticMethod() throws Exception {
+    final DynMethods.Builder builder = new DynMethods.Builder("concat")
+        .impl(Concatenator.class, String.class, String.class);
+
+    TestUtils.assertThrows("Should complain that method is not static",
+        IllegalStateException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return builder.buildStatic();
+          }
+        });
+
+    TestUtils.assertThrows("Should complain that method is not static",
+        IllegalStateException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return builder.buildStaticChecked();
+          }
+        });
+
+    final DynMethods.UnboundMethod cat2 = builder.buildChecked();
+    Assert.assertFalse("concat(String,String) should not be static",
+        cat2.isStatic());
+
+    TestUtils.assertThrows("Should complain that method is not static",
+        IllegalStateException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return cat2.asStatic();
+          }
+        });
+  }
+
+  @Test
+  public void testConstructorImpl() throws Exception {
+    final DynMethods.Builder builder = new DynMethods.Builder("newConcatenator")
+        .ctorImpl(Concatenator.class, String.class)
+        .impl(Concatenator.class, String.class);
+
+    DynMethods.UnboundMethod newConcatenator = builder.buildChecked();
+    Assert.assertTrue("Should find constructor implementation",
+        newConcatenator instanceof DynConstructors.Ctor);
+    Assert.assertTrue("Constructor should be a static method",
+        newConcatenator.isStatic());
+    Assert.assertFalse("Constructor should not be NOOP",
+        newConcatenator.isNoop());
+
+    // constructors cannot be bound
+    TestUtils.assertThrows("Should complain that ctor method is static",
+        IllegalStateException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return builder.buildChecked(new Concatenator());
+          }
+        });
+    TestUtils.assertThrows("Should complain that ctor method is static",
+        IllegalStateException.class, new Callable() {
+          @Override
+          public Object call() throws Exception {
+            return builder.build(new Concatenator());
+          }
+        });
+
+    Concatenator concatenator = newConcatenator.asStatic().invoke("*");
+    Assert.assertEquals("Should function as a concatenator",
+        "a*b", concatenator.concat("a", "b"));
+
+    concatenator = newConcatenator.asStatic().invokeChecked("@");
+    Assert.assertEquals("Should function as a concatenator",
+        "a@b", concatenator.concat("a", "b"));
+  }
+
+  @Test
+  public void testConstructorImplAfterFactoryMethod() throws Exception {
+    DynMethods.UnboundMethod newConcatenator = new DynMethods.Builder("newConcatenator")
+        .impl(Concatenator.class, String.class)
+        .ctorImpl(Concatenator.class, String.class)
+        .buildChecked();
+
+    Assert.assertFalse("Should find factory method before constructor method",
+        newConcatenator instanceof DynConstructors.Ctor);
+  }
+
+  @Test
+  public void testNoop() throws Exception {
+    // noop can be unbound, bound, or static
+    DynMethods.UnboundMethod noop = new DynMethods.Builder("concat")
+        .impl("not.a.RealClass", String.class, String.class)
+        .orNoop()
+        .buildChecked();
+
+    Assert.assertTrue("No implementation found, should return NOOP",
+        noop.isNoop());
+    Assert.assertNull("NOOP should always return null",
+        noop.invoke(new Concatenator(), "a"));
+    Assert.assertNull("NOOP can be called with null",
+        noop.invoke(null, "a"));
+    Assert.assertNull("NOOP can be bound",
+        noop.bind(new Concatenator()).invoke("a"));
+    Assert.assertNull("NOOP can be bound to null",
+        noop.bind(null).invoke("a"));
+    Assert.assertNull("NOOP can be static",
+        noop.asStatic().invoke("a"));
+  }
+}

http://git-wip-us.apache.org/repos/asf/parquet-mr/blob/ddbeb4dd/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index df4bbd3..0d4df8a 100644
--- a/pom.xml
+++ b/pom.xml
@@ -89,6 +89,12 @@
     <avro.version>1.8.1</avro.version>
     <guava.version>20.0</guava.version>
     <mockito.version>1.10.19</mockito.version>
+
+    <!-- parquet-cli dependencies -->
+    <opencsv.version>2.3</opencsv.version>
+    <jackson2.version>2.3.1</jackson2.version>
+    <jcommander.version>1.35</jcommander.version>
+    <commons-codec.version>1.10</commons-codec.version>
   </properties>
 
   <modules>
@@ -97,6 +103,7 @@
     <module>parquet-benchmarks</module>
     <module>parquet-cascading</module>
     <module>parquet-cascading3</module>
+    <module>parquet-cli</module>
     <module>parquet-column</module>
     <module>parquet-common</module>
     <module>parquet-encoding</module>


Mime
View raw message