embulk 0.8.14-java → 0.8.15-java

data/embulk-docs/src/release.rst

@@ -4,6 +4,7 @@ Release Notes
 .. toctree::
     :maxdepth: 1
 
+    release/release-0.8.15
     release/release-0.8.14
     release/release-0.8.13
     release/release-0.8.12

data/embulk-docs/src/release/release-0.8.15.rst

@@ -0,0 +1,17 @@
+Release 0.8.15
+==================================
+
+General Changes
+------------------
+
+* Added several rules option to rename filter plugin. [#494]
+
+  * http://www.embulk.org/docs/built-in.html#rename-filter-plugin
+
+* Introduced SkipTransactionException to stop Embulk before the transaction starts. [#498]
+
+* Added embulk-test package, which is an utility library to be used from the test cases of Java-based input plugins. [#503]
+
+Release Date
+------------------
+2016-11-04

data/embulk-standards/src/main/java/org/embulk/standards/RenameFilterPlugin.java

@@ -7,13 +7,28 @@ import org.embulk.config.ConfigSource;
 import org.embulk.config.Task;
 import org.embulk.config.TaskSource;
 import org.embulk.spi.Column;
+import org.embulk.spi.Exec;
 import org.embulk.spi.FilterPlugin;
 import org.embulk.spi.PageOutput;
 import org.embulk.spi.Schema;
 
+import com.google.common.base.Optional;
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableSet;
+
+import org.slf4j.Logger;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
+import java.util.regex.PatternSyntaxException;
 
+import javax.validation.constraints.Min;
+import javax.validation.constraints.Size;
 
 public class RenameFilterPlugin
         implements FilterPlugin
@@ -71,7 +86,6 @@ public class RenameFilterPlugin
         return output;
     }
 
-
     // Extending Task is required to be deserialized with ConfigSource.loadConfig()
     // although this Rule is not really a Task.
     // TODO(dmikurube): Revisit this to consider how not to extend Task for this.
@@ -82,12 +96,371 @@ public class RenameFilterPlugin
         String getRule();
     }
 
+    private interface CharacterTypesRule
+            extends Rule {
+        @Config("pass_types")
+        @ConfigDefault("[]")
+        List<String> getPassTypes();
+
+        @Config("pass_characters")
+        @ConfigDefault("\"\"")
+        String getPassCharacters();
+
+        @Config("replace")
+        @ConfigDefault("\"_\"")
+        @Size(min = 1, max = 1)
+        String getReplace();
+    }
+
+    private interface FirstCharacterTypesRule
+            extends Rule {
+        @Config("replace")
+        @ConfigDefault("null")
+        Optional<String> getReplace();
+
+        @Config("pass_types")
+        @ConfigDefault("[]")
+        List<String> getPassTypes();
+
+        @Config("pass_characters")
+        @ConfigDefault("\"\"")
+        String getPassCharacters();
+
+        @Config("prefix")
+        @ConfigDefault("null")
+        Optional<String> getPrefix();
+    }
+
+    private interface TruncateRule
+            extends Rule {
+        @Config("max_length")
+        @ConfigDefault("128")
+        @Min(0)
+        int getMaxLength();
+    }
+
+    private interface RegexReplaceRule
+            extends Rule {
+        @Config("match")
+        String getMatch();
+
+        @Config("replace")
+        String getReplace();
+    }
+
+    private interface UniqueNumberSuffixRule
+            extends Rule {
+        @Config("delimiter")
+        @ConfigDefault("\"_\"")
+        String getDelimiter();
+
+        @Config("digits")
+        @ConfigDefault("null")
+        Optional<Integer> getDigits();
+
+        @Config("max_length")
+        @ConfigDefault("null")
+        Optional<Integer> getMaxLength();
+
+        @Config("offset")
+        @ConfigDefault("1")
+        @Min(0)
+        int getOffset();
+    }
+
     private Schema applyRule(ConfigSource ruleConfig, Schema inputSchema) throws ConfigException
     {
         Rule rule = ruleConfig.loadConfig(Rule.class);
         switch (rule.getRule()) {
+        case "character_types":
+            return applyCharacterTypesRule(inputSchema, ruleConfig.loadConfig(CharacterTypesRule.class));
+        case "first_character_types":
+            return applyFirstCharacterTypesRule(inputSchema, ruleConfig.loadConfig(FirstCharacterTypesRule.class));
+        case "lower_to_upper":
+            return applyLowerToUpperRule(inputSchema);
+        case "regex_replace":
+            return applyRegexReplaceRule(inputSchema, ruleConfig.loadConfig(RegexReplaceRule.class));
+        case "truncate":
+            return applyTruncateRule(inputSchema, ruleConfig.loadConfig(TruncateRule.class));
+        case "upper_to_lower":
+            return applyUpperToLowerRule(inputSchema);
+        case "unique_number_suffix":
+            return applyUniqueNumberSuffixRule(inputSchema, ruleConfig.loadConfig(UniqueNumberSuffixRule.class));
         default:
             throw new ConfigException("Renaming rule \"" +rule+ "\" is unknown");
         }
     }
+
+    private Schema applyCharacterTypesRule(Schema inputSchema, CharacterTypesRule rule) {
+        final List<String> passTypes = rule.getPassTypes();
+        final String passCharacters = rule.getPassCharacters();
+        final String replace = rule.getReplace();
+
+        if (replace.isEmpty()) {
+            throw new ConfigException("\"replace\" in \"character_types\" must not be explicitly empty");
+        }
+        if (replace.length() != 1) {
+            throw new ConfigException("\"replace\" in \"character_types\" must contain just 1 character");
+        }
+        // TODO(dmikurube): Revisit this for better escaping.
+        if (passCharacters.contains("\\E")) {
+            throw new ConfigException("\"pass_characters\" in \"character_types\" must not contain \"\\E\"");
+        }
+
+        StringBuilder regexBuilder = new StringBuilder();
+        regexBuilder.append("[^");
+        for (String target : passTypes) {
+            if (CHARACTER_TYPE_KEYWORDS.containsKey(target)) {
+                regexBuilder.append(CHARACTER_TYPE_KEYWORDS.get(target));
+            } else {
+                throw new ConfigException("\"" +target+ "\" is an unknown character type keyword");
+            }
+        }
+        if (!passCharacters.isEmpty()) {
+            regexBuilder.append("\\Q");
+            regexBuilder.append(passCharacters);
+            regexBuilder.append("\\E");
+        }
+        regexBuilder.append("]");
+
+        Schema.Builder schemaBuilder = Schema.builder();
+        for (Column column : inputSchema.getColumns()) {
+            schemaBuilder.add(column.getName().replaceAll(regexBuilder.toString(), replace), column.getType());
+        }
+        return schemaBuilder.build();
+    }
+
+    private Schema applyFirstCharacterTypesRule(Schema inputSchema, FirstCharacterTypesRule rule) {
+        final Optional<String> replace = rule.getReplace();
+        final List<String> passTypes = rule.getPassTypes();
+        final String passCharacters = rule.getPassCharacters();
+        final Optional<String> prefix = rule.getPrefix();
+
+        if (replace.isPresent() && replace.get().length() != 1) {
+            throw new ConfigException("\"replace\" in \"first_character_types\" must contain just 1 character if specified");
+        }
+        if (prefix.isPresent() && prefix.get().length() != 1) {
+            throw new ConfigException("\"prefix\" in \"first_character_types\" must contain just 1 character if specified");
+        }
+        if (prefix.isPresent() && replace.isPresent()) {
+            throw new ConfigException("\"replace\" and \"prefix\" in \"first_character_types\" must not be specified together");
+        }
+        if ((!prefix.isPresent()) && (!replace.isPresent())) {
+            throw new ConfigException("Either of \"replace\" or \"prefix\" must be specified in \"first_character_types\"");
+        }
+        // TODO(dmikurube): Revisit this for better escaping.
+        if (passCharacters.contains("\\E")) {
+            throw new ConfigException("\"pass_characters\" in \"first_character_types\" must not contain \"\\E\"");
+        }
+
+        StringBuilder regexBuilder = new StringBuilder();
+        regexBuilder.append("^[^");
+        for (String target : passTypes) {
+            if (CHARACTER_TYPE_KEYWORDS.containsKey(target)) {
+                regexBuilder.append(CHARACTER_TYPE_KEYWORDS.get(target));
+            } else {
+                throw new ConfigException("\"" +target+ "\" is an unknown character type keyword");
+            }
+        }
+        if (!passCharacters.isEmpty()) {
+            regexBuilder.append("\\Q");
+            regexBuilder.append(passCharacters);
+            regexBuilder.append("\\E");
+        }
+        regexBuilder.append("].*");
+
+        Schema.Builder schemaBuidler = Schema.builder();
+        for (Column column : inputSchema.getColumns()) {
+            String name = column.getName();
+            if (name.matches(regexBuilder.toString())) {
+                if (replace.isPresent()) {
+                    name = replace.get() + name.substring(1);
+                }
+                else if (prefix.isPresent()) {
+                    name = prefix.get() + name;
+                }
+            }
+            schemaBuidler.add(name, column.getType());
+        }
+        return schemaBuidler.build();
+    }
+
+    private Schema applyLowerToUpperRule(Schema inputSchema) {
+        Schema.Builder builder = Schema.builder();
+        for (Column column : inputSchema.getColumns()) {
+            builder.add(column.getName().toUpperCase(Locale.ENGLISH), column.getType());
+        }
+        return builder.build();
+    }
+
+    private Schema applyTruncateRule(Schema inputSchema, TruncateRule rule) {
+        Schema.Builder builder = Schema.builder();
+        for (Column column : inputSchema.getColumns()) {
+            if (column.getName().length() <= rule.getMaxLength()) {
+                builder.add(column.getName(), column.getType());
+            }
+            else {
+                try {
+                    builder.add(column.getName().substring(0, rule.getMaxLength()), column.getType());
+                }
+                catch (IndexOutOfBoundsException ex) {
+                    logger.error("FATAL unexpected error in \"truncate\" rule: substring failed.");
+                    throw new AssertionError("FATAL unexpected error in \"truncate\" rule: substring failed.", ex);
+                }
+            }
+        }
+        return builder.build();
+    }
+
+    private Schema applyUpperToLowerRule(Schema inputSchema) {
+        Schema.Builder builder = Schema.builder();
+        for (Column column : inputSchema.getColumns()) {
+            builder.add(column.getName().toLowerCase(Locale.ENGLISH), column.getType());
+        }
+        return builder.build();
+    }
+
+    private Schema applyRegexReplaceRule(Schema inputSchema, RegexReplaceRule rule) {
+        final String match = rule.getMatch();
+        final String replace = rule.getReplace();
+
+        Schema.Builder builder = Schema.builder();
+        for (Column column : inputSchema.getColumns()) {
+            // TODO(dmikurube): Check if we need a kind of sanitization?
+            try {
+                builder.add(column.getName().replaceAll(match, replace), column.getType());
+            }
+            catch (PatternSyntaxException ex) {
+                throw new ConfigException(ex);
+            }
+        }
+        return builder.build();
+    }
+
+    /**
+     * Resolves conflicting column names by suffixing numbers.
+     *
+     * Conflicts are resolved by the following rules. The rules should not be changed casually because changing the
+     * rules breaks compatibility.
+     *
+     * 1. Count all duplicates in the original column names. Indexes are counted up per original column name.
+     * 2. Fix new column names from the left to the right
+     *   - Try to append the current index for the original column name (with truncation if requested (not implemented))
+     *     - Fix the new name if no duplication is found with fixed column names on the left and original column names
+     *     - Retry with an index incremented if a duplication is found with fixed column names on the left
+     *
+     * Examples:
+     *     [c, c1, c1,   c2, c,   c3]
+     * ==> [c, c1, c1_2, c2, c_2, c3]
+     *
+     * If a newly suffixed name newly conflicts with other columns, the index is just skipped. For example:
+     *     [c, c,   c_0, c_1, c_2]
+     * ==> [c, c_3, c_0, c_1, c_2]
+     *
+     * If truncation is requested simultaneously with uniqueness (not implemented), it should work like:
+     *     [co, c, co  , c  , co  , c  , ..., co  , c  , co  , c   , co  , c   ]
+     * ==> [co, c, co_2, c_2, co_3, c_3, ..., co_9, c_9, c_10, c_11, c_12, c_13] (max_length:4)
+     *
+     *     [co, co  , co  , ..., co  , c, c  , ..., c  , co  , c  , co  , c  , co  , c   ]
+     * ==> [co, co_2, co_3, ..., co_9, c, c_2, ..., c_7, c_10, c_8, c_11, c_9, c_12, c_13] (max_length:4)
+     *
+     * Note that a delimiter should not be omitted. Recurring conflicts may confuse users.
+     *     [c, c,  c,  ..., c,   c,   c,   c,   c1, c1,  c1]
+     * NG: [c, c2, c3, ..., c10, c11, c12, c13, c1, c12, c13] (not unique!)
+     * ==> [c, c2, c3, ..., c10, c11, c12, c13, c1, c14, c15] (confusing)
+     */
+    private Schema applyUniqueNumberSuffixRule(Schema inputSchema, UniqueNumberSuffixRule rule) {
+        final String delimiter = rule.getDelimiter();
+        final Optional<Integer> digits = rule.getDigits();
+        final Optional<Integer> maxLength = rule.getMaxLength();
+        final int offset = rule.getOffset();
+
+        // |delimiter| must consist of just 1 character to check quickly that it does not contain any digit.
+        if (delimiter == null || delimiter.length() != 1 || Character.isDigit(delimiter.charAt(0))) {
+            throw new ConfigException("\"delimiter\" in rule \"unique_number_suffix\" must contain just 1 non-digit character");
+        }
+        if (maxLength.isPresent() && maxLength.get() < minimumMaxLengthInUniqueNumberSuffix) {
+            throw new ConfigException("\"max_length\" in rule \"unique_number_suffix\" must be larger than " +(minimumMaxLengthInUniqueNumberSuffix-1));
+        }
+        if (maxLength.isPresent() && digits.isPresent() && maxLength.get() < digits.get() + delimiter.length()) {
+            throw new ConfigException("\"max_length\" in rule \"unique_number_suffix\" must be larger than \"digits\"");
+        }
+        int digitsOfNumberOfColumns = Integer.toString(inputSchema.getColumnCount() + offset - 1).length();
+        if (maxLength.isPresent() && maxLength.get() <= digitsOfNumberOfColumns) {
+            throw new ConfigException("\"max_length\" in rule \"unique_number_suffix\" must be larger than digits of ((number of columns) + \"offset\" - 1)");
+        }
+        if (digits.isPresent() && digits.get() <= digitsOfNumberOfColumns) {
+            throw new ConfigException("\"digits\" in rule \"unique_number_suffix\" must be larger than digits of ((number of columns) + \"offset\" - 1)");
+        }
+
+        // Columns should not be truncated here initially. Uniqueness should be identified before truncated.
+
+        // Iterate for initial states.
+        HashSet<String> originalColumnNames = new HashSet<>();
+        HashMap<String, Integer> columnNameCountups = new HashMap<>();
+        for (Column column : inputSchema.getColumns()) {
+            originalColumnNames.add(column.getName());
+            columnNameCountups.put(column.getName(), offset);
+        }
+
+        Schema.Builder outputBuilder = Schema.builder();
+
+        HashSet<String> fixedColumnNames = new HashSet<>();
+        for (Column column : inputSchema.getColumns()) {
+            String truncatedName = column.getName();
+            if (column.getName().length() > maxLength.or(Integer.MAX_VALUE)) {
+                truncatedName = column.getName().substring(0, maxLength.get());
+            }
+
+            // Fix with the new name candidate if the new name does not conflict with the fixed names on the left.
+            // Conflicts with original names do not matter here.
+            if (!fixedColumnNames.contains(truncatedName)) {
+                // The original name is counted up.
+                columnNameCountups.put(column.getName(), columnNameCountups.get(column.getName()) + 1);
+                // The truncated name is fixed.
+                fixedColumnNames.add(truncatedName);
+                outputBuilder.add(truncatedName, column.getType());
+                continue;
+            }
+
+            int index = columnNameCountups.get(column.getName());
+            String concatenatedName;
+            do {
+                // This can be replaced with String#format(Locale.ENGLISH, ...), but Java's String#format does not
+                // have variable widths ("%*d" in C's printf). It cannot be very simple with String#format.
+                String differentiatorString = Integer.toString(index);
+                if (digits.isPresent() && (digits.get() > differentiatorString.length())) {
+                    differentiatorString =
+                        Strings.repeat("0", digits.get() - differentiatorString.length()) + differentiatorString;
+                }
+                differentiatorString = delimiter + differentiatorString;
+                concatenatedName = column.getName() + differentiatorString;
+                if (concatenatedName.length() > maxLength.or(Integer.MAX_VALUE)) {
+                    concatenatedName =
+                        column.getName().substring(0, maxLength.get() - differentiatorString.length())
+                        + differentiatorString;
+                }
+                ++index;
+            // Conflicts with original names matter when creating new names with suffixes.
+            } while (fixedColumnNames.contains(concatenatedName) || originalColumnNames.contains(concatenatedName));
+            // The original name is counted up.
+            columnNameCountups.put(column.getName(), index);
+            // The concatenated&truncated name is fixed.
+            fixedColumnNames.add(concatenatedName);
+            outputBuilder.add(concatenatedName, column.getType());
+        }
+        return outputBuilder.build();
+    }
+
+    private static final ImmutableMap<String, String> CHARACTER_TYPE_KEYWORDS =
+        new ImmutableMap.Builder<String, String>().put("a-z", "a-z")
+                                                  .put("A-Z", "A-Z")
+                                                  .put("0-9", "0-9")
+                                                  .build();
+
+    // TODO(dmikurube): Revisit the limitation.
+    // It should be practically acceptable to assume any output accepts column names with 8 characters at least...
+    private static final int minimumMaxLengthInUniqueNumberSuffix = 8;
+
+    private final Logger logger = Exec.getLogger(getClass());
 }

data/embulk-standards/src/test/java/org/embulk/standards/TestRenameFilterPlugin.java

@@ -2,19 +2,28 @@ package org.embulk.standards;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
 import org.embulk.EmbulkTestRuntime;
 import org.embulk.config.ConfigException;
 import org.embulk.config.ConfigSource;
 import org.embulk.config.TaskSource;
+import org.embulk.config.TaskValidationException;
 import org.embulk.spi.Column;
 import org.embulk.spi.FilterPlugin;
 import org.embulk.spi.Exec;
 import org.embulk.spi.Schema;
 import org.embulk.spi.SchemaConfigException;
 import org.embulk.standards.RenameFilterPlugin.PluginTask;
+
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.regex.PatternSyntaxException;
 
 import static org.embulk.spi.type.Types.STRING;
 import static org.embulk.spi.type.Types.TIMESTAMP;
@@ -27,11 +36,16 @@ public class TestRenameFilterPlugin
     @Rule
     public EmbulkTestRuntime runtime = new EmbulkTestRuntime();
 
+    @Rule
+    public ExpectedException exception = ExpectedException.none();
+
     private final Schema SCHEMA = Schema.builder()
             .add("_c0", STRING)
             .add("_c1", TIMESTAMP)
             .build();
 
+    private final String DEFAULT = "__use_default__";
+
     private RenameFilterPlugin filter;
 
     @Before
@@ -137,4 +151,862 @@ public class TestRenameFilterPlugin
             assertTrue(t instanceof ConfigException);
         }
     }
+
+    @Test
+    public void checkRuleLowerToUpperRule()
+    {
+        final String original[] = { "_C0", "_C1", "_c2" };
+        final String expected[] = { "_C0", "_C1", "_C2" };
+        ConfigSource config = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.of("rule", "lower_to_upper")));
+        renameAndCheckSchema(config, original, expected);
+    }
+
+    @Test
+    public void checkTruncateRule()
+    {
+        final String original[] = { "foo", "bar", "gj", "foobar", "foobarbaz" };
+        final String expected[] = { "foo", "bar", "gj", "foo",    "foo"       };
+        ConfigSource config = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.of("rule", "truncate", "max_length", "3")));
+        renameAndCheckSchema(config, original, expected);
+    }
+
+    @Test
+    public void checkTruncateRuleDefault()
+    {
+        final String original[] = {
+            "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890" };
+        final String expected[] = {
+            "12345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678" };
+        ConfigSource config = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.of("rule", "truncate")));
+        renameAndCheckSchema(config, original, expected);
+    }
+
+    @Test
+    public void checkTruncateRuleNegative()
+    {
+        final String original[] = { "foo" };
+        ConfigSource config = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.of("rule", "truncate", "max_length", -1)));
+        exception.expect(TaskValidationException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        renameAndCheckSchema(config, original, original);
+    }
+
+    @Test
+    public void checkRuleUpperToLowerRule()
+    {
+        final String original[] = { "_C0", "_C1", "_c2" };
+        final String expected[] = { "_c0", "_c1", "_c2" };
+        ConfigSource config = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.of("rule", "upper_to_lower")));
+        renameAndCheckSchema(config, original, expected);
+    }
+
+    @Test
+    public void checkCharacterTypesRulePassAlphabet()
+    {
+        final String original[] = { "Internal$Foo0123--Bar" };
+        final String expected[] = { "Internal_Foo______Bar" };
+        final String pass_types[] = { "a-z", "A-Z" };
+        checkCharacterTypesRuleInternal(original, expected, pass_types, "");
+    }
+
+    @Test
+    public void checkCharacterTypesRulePassAlphanumeric()
+    {
+        final String original[] = { "Internal$Foo0123--Bar" };
+        final String expected[] = { "Internal_Foo0123__Bar" };
+        final String pass_types[] = { "a-z", "A-Z", "0-9" };
+        checkCharacterTypesRuleInternal(original, expected, pass_types, "");
+    }
+
+    @Test
+    public void checkCharacterTypesRulePassLowercase()
+    {
+        final String original[] = { "Internal$Foo0123--Bar" };
+        final String expected[] = { "_nternal__oo_______ar" };
+        final String pass_types[] = { "a-z" };
+        checkCharacterTypesRuleInternal(original, expected, pass_types, "");
+    }
+
+    @Test
+    public void checkCharacterTypesRulePassLowerwording()
+    {
+        final String original[] = { "Internal$Foo_0123--Bar" };
+        final String expected[] = { "-nternal--oo_0123---ar" };
+        final String pass_types[] = { "a-z", "0-9" };
+        checkCharacterTypesRuleInternal(original, expected, pass_types, "_", "-");
+    }
+
+    @Test
+    public void checkCharacterTypesRulePassNumeric()
+    {
+        final String original[] = { "Internal$Foo_0123--Bar" };
+        final String expected[] = { "_____________0123_____" };
+        final String pass_types[] = { "0-9" };
+        checkCharacterTypesRuleInternal(original, expected, pass_types, "");
+    }
+
+    @Test
+    public void checkCharacterTypesRulePassUppercase()
+    {
+        final String original[] = { "Internal$Foo_0123--Bar" };
+        final String expected[] = { "I________F_________B__" };
+        final String pass_types[] = { "A-Z" };
+        checkCharacterTypesRuleInternal(original, expected, pass_types, "");
+    }
+
+    @Test
+    public void checkCharacterTypesRulePassUpperwording()
+    {
+        final String original[] = { "Internal$Foo_0123--Bar" };
+        final String expected[] = { "I--------F--_0123--B--" };
+        final String pass_types[] = { "A-Z", "0-9" };
+        checkCharacterTypesRuleInternal(original, expected, pass_types, "_", "-");
+    }
+
+    @Test
+    public void checkCharacterTypesRulePassWording()
+    {
+        final String original[] = { "Internal$Foo_0123--Bar" };
+        final String expected[] = { "Internal-Foo_0123--Bar" };
+        final String pass_types[] = { "a-z", "A-Z", "0-9" };
+        checkCharacterTypesRuleInternal(original, expected, pass_types, "_", "-");
+    }
+
+    @Test
+    public void checkCharacterTypesRulePassCombination()
+    {
+        final String original[] = { "@Foobar0123_$" };
+        final String expected[] = { "__oobar0123__" };
+        final String pass_types[] = { "0-9", "a-z" };
+        checkCharacterTypesRuleInternal(original, expected, pass_types, "");
+    }
+
+    @Test
+    public void checkCharacterTypesRuleLongReplace()
+    {
+        final String original[] = { "fooBAR" };
+        final String pass_types[] = { "a-z" };
+        exception.expect(TaskValidationException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkCharacterTypesRuleInternal(original, original, pass_types, "", "___");
+    }
+
+    @Test
+    public void checkCharacterTypesRuleEmptyReplace()
+    {
+        final String original[] = { "fooBAR" };
+        final String pass_types[] = { "a-z" };
+        exception.expect(TaskValidationException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkCharacterTypesRuleInternal(original, original, pass_types, "", "");
+    }
+
+    // TODO(dmikurube): Test a nil/null replace.
+    // - rule: character_types
+    //   delimiter:
+
+    @Test
+    public void checkCharacterTypesRuleUnknownType()
+    {
+        final String original[] = { "fooBAR" };
+        final String pass_types[] = { "some_unknown_keyword" };
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkCharacterTypesRuleInternal(original, original, pass_types, "");
+    }
+
+    @Test
+    public void checkCharacterTypesRuleForbiddenCharSequence()
+    {
+        final String original[] = { "fooBAR" };
+        final String pass_types[] = {};
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkCharacterTypesRuleInternal(original, original, pass_types, "\\E");
+    }
+
+    private void checkCharacterTypesRuleInternal(
+            final String original[],
+            final String expected[],
+            final String pass_types[],
+            final String pass_characters)
+    {
+        checkCharacterTypesRuleInternal(original, expected, pass_types, pass_characters, DEFAULT);
+    }
+
+    private void checkCharacterTypesRuleInternal(
+            final String original[],
+            final String expected[],
+            final String pass_types[],
+            final String pass_characters,
+            final String replace)
+    {
+        HashMap<String, Object> parameters = new HashMap<>();
+        parameters.put("rule", "character_types");
+        if (pass_types != null) {
+            parameters.put("pass_types", ImmutableList.copyOf(pass_types));
+        }
+        if (!pass_characters.equals(DEFAULT)) {
+            parameters.put("pass_characters", pass_characters);
+        }
+        if (!replace.equals(DEFAULT)) {
+            parameters.put("replace", replace);
+        }
+        ConfigSource config = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.copyOf(parameters)));
+        renameAndCheckSchema(config, original, expected);
+    }
+
+    @Test
+    public void checkRegexReplaceRule1()
+    {
+        final String original[] = { "foobarbaz" };
+        final String expected[] = { "hogebarbaz" };
+        checkRegexReplaceRuleInternal(original, expected, "foo", "hoge");
+    }
+
+    @Test
+    public void checkRegexReplaceRule2()
+    {
+        final String original[] = { "200_dollars" };
+        final String expected[] = { "USD200" };
+        checkRegexReplaceRuleInternal(original, expected, "([0-9]+)_dollars", "USD$1");
+    }
+
+    private void checkRegexReplaceRuleInternal(
+            final String original[],
+            final String expected[],
+            final String match,
+            final String replace)
+    {
+        HashMap<String, Object> parameters = new HashMap<>();
+        parameters.put("rule", "regex_replace");
+        parameters.put("match", match);
+        parameters.put("replace", replace);
+        ConfigSource config = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.copyOf(parameters)));
+        renameAndCheckSchema(config, original, expected);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceSingleHyphen()
+    {
+        final String original[] = { "foo", "012foo", "@bar", "BAZ", "&ban", "_jar", "*zip", "-zap" };
+        final String expected[] = { "_oo", "_12foo", "_bar", "_AZ", "_ban", "_jar", "_zip", "-zap" };
+        final String pass_types[] = {};
+        checkFirstCharacterTypesRuleReplaceInternal(original, expected, "_", pass_types, "-");
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceMultipleSingles()
+    {
+        final String original[] = { "foo", "012foo", "@bar", "BAZ", "&ban", "_jar", "*zip", "-zap" };
+        final String expected[] = { "_oo", "_12foo", "@bar", "_AZ", "_ban", "_jar", "*zip", "-zap" };
+        final String pass_types[] = {};
+        checkFirstCharacterTypesRuleReplaceInternal(original, expected, "_", pass_types, "-@*");
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceAlphabet()
+    {
+        final String original[] = { "foo", "012foo", "@bar", "BAZ", "&ban", "_jar", "*zip", "-zap" };
+        final String expected[] = { "foo", "_12foo", "_bar", "BAZ", "_ban", "_jar", "_zip", "_zap" };
+        final String pass_types[] = { "a-z", "A-Z" };
+        checkFirstCharacterTypesRuleReplaceInternal(original, expected, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceAlphanumeric()
+    {
+        final String original[] = { "foo", "012foo", "@bar", "BAZ", "&ban", "_jar", "*zip", "-zap" };
+        final String expected[] = { "foo", "012foo", "_bar", "BAZ", "_ban", "_jar", "_zip", "_zap" };
+        final String pass_types[] = { "a-z", "A-Z", "0-9" };
+        checkFirstCharacterTypesRuleReplaceInternal(original, expected, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceLowercase()
+    {
+        final String original[] = { "foo", "012foo", "@bar", "BAZ", "&ban", "_jar", "*zip", "-zap" };
+        final String expected[] = { "foo", "_12foo", "_bar", "_AZ", "_ban", "_jar", "_zip", "_zap" };
+        final String pass_types[] = { "a-z" };
+        checkFirstCharacterTypesRuleReplaceInternal(original, expected, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceLowerwording()
+    {
+        final String original[] = { "foo", "012foo", "@bar", "BAZ", "&ban", "_jar", "*zip", "-zap" };
+        final String expected[] = { "foo", "012foo", "-bar", "-AZ", "-ban", "_jar", "-zip", "-zap" };
+        final String pass_types[] = { "a-z", "0-9" };
+        checkFirstCharacterTypesRuleReplaceInternal(original, expected, "-", pass_types, "_");
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceNumeric()
+    {
+        final String original[] = { "foo", "012foo", "@bar", "BAZ", "&ban", "_jar", "*zip", "-zap" };
+        final String expected[] = { "_oo", "012foo", "_bar", "_AZ", "_ban", "_jar", "_zip", "_zap" };
+        final String pass_types[] = { "0-9" };
+        checkFirstCharacterTypesRuleReplaceInternal(original, expected, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceUppercase()
+    {
+        final String original[] = { "foo", "012foo", "@bar", "BAZ", "&ban", "_jar", "*zip", "-zap" };
+        final String expected[] = { "_oo", "_12foo", "_bar", "BAZ", "_ban", "_jar", "_zip", "_zap" };
+        final String pass_types[] = { "A-Z" };
+        checkFirstCharacterTypesRuleReplaceInternal(original, expected, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceUpperwording()
+    {
+        final String original[] = { "foo", "012foo", "@bar", "BAZ", "&ban", "_jar", "*zip", "-zap" };
+        final String expected[] = { "-oo", "012foo", "-bar", "BAZ", "-ban", "_jar", "-zip", "-zap" };
+        final String pass_types[] = { "A-Z", "0-9" };
+        checkFirstCharacterTypesRuleReplaceInternal(original, expected, "-", pass_types, "_");
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceWording()
+    {
+        final String original[] = { "foo", "012foo", "@bar", "BAZ", "&ban", "_jar", "*zip", "-zap" };
+        final String expected[] = { "foo", "012foo", "$bar", "BAZ", "$ban", "_jar", "$zip", "$zap" };
+        final String pass_types[] = { "a-z", "A-Z", "0-9" };
+        checkFirstCharacterTypesRuleReplaceInternal(original, expected, "$", pass_types, "_");
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceUnknownFirst()
+    {
+        final String original[] = { "foo" };
+        final String pass_types[] = { "some_unknown_type" };
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkFirstCharacterTypesRuleReplaceInternal(original, original, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleReplaceForbiddenCharSequence()
+    {
+        final String original[] = { "foo" };
+        final String pass_types[] = {};
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkFirstCharacterTypesRuleReplaceInternal(original, original, "_", pass_types, "\\E");
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixSingleHyphen()
+    {
+        final String original[] = { "foo",  "012foo",  "@bar",  "BAZ",  "&ban",  "_jar",  "*zip",  "-zap"  };
+        final String expected[] = { "_foo", "_012foo", "_@bar", "_BAZ", "_&ban", "__jar", "_*zip",  "-zap" };
+        final String pass_types[] = {};
+        checkFirstCharacterTypesRulePrefixInternal(original, expected, "_", pass_types, "-");
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixMultipleSingles()
+    {
+        final String original[] = { "foo",  "012foo",  "@bar", "BAZ",  "&ban",  "_jar",  "*zip", "-zap"  };
+        final String expected[] = { "_foo", "_012foo", "@bar", "_BAZ", "_&ban", "__jar", "*zip", "-zap" };
+        final String pass_types[] = {};
+        checkFirstCharacterTypesRulePrefixInternal(original, expected, "_", pass_types, "-@*");
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixAlphabet()
+    {
+        final String original[] = { "foo", "012foo",  "@bar",  "BAZ", "&ban",  "_jar",  "*zip",  "-zap"  };
+        final String expected[] = { "foo", "_012foo", "_@bar", "BAZ", "_&ban", "__jar", "_*zip", "_-zap" };
+        final String pass_types[] = { "a-z", "A-Z" };
+        checkFirstCharacterTypesRulePrefixInternal(original, expected, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixAlphanumeric()
+    {
+        final String original[] = { "foo", "012foo", "@bar",  "BAZ", "&ban",  "_jar",  "*zip",  "-zap"  };
+        final String expected[] = { "foo", "012foo", "_@bar", "BAZ", "_&ban", "__jar", "_*zip", "_-zap" };
+        final String pass_types[] = { "a-z", "A-Z", "0-9" };
+        checkFirstCharacterTypesRulePrefixInternal(original, expected, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixLowercase()
+    {
+        final String original[] = { "foo", "012foo",  "@bar",  "BAZ",  "&ban",  "_jar",  "*zip",  "-zap"  };
+        final String expected[] = { "foo", "_012foo", "_@bar", "_BAZ", "_&ban", "__jar", "_*zip", "_-zap" };
+        final String pass_types[] = { "a-z" };
+        checkFirstCharacterTypesRulePrefixInternal(original, expected, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixLowerwording()
+    {
+        final String original[] = { "foo", "012foo", "@bar",  "BAZ",  "&ban",  "_jar",  "*zip",  "-zap"  };
+        final String expected[] = { "foo", "012foo", "-@bar", "-BAZ", "-&ban", "_jar", "-*zip", "--zap" };
+        final String pass_types[] = { "a-z", "0-9" };
+        checkFirstCharacterTypesRulePrefixInternal(original, expected, "-", pass_types, "_");
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixNumeric()
+    {
+        final String original[] = { "foo",  "012foo", "@bar",  "BAZ",  "&ban",  "_jar",  "*zip",  "-zap"  };
+        final String expected[] = { "_foo", "012foo", "_@bar", "_BAZ", "_&ban", "__jar", "_*zip", "_-zap" };
+        final String pass_types[] = { "0-9" };
+        checkFirstCharacterTypesRulePrefixInternal(original, expected, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixUppercase()
+    {
+        final String original[] = { "foo",  "012foo",  "@bar",  "BAZ",  "&ban",  "_jar",  "*zip",  "-zap"  };
+        final String expected[] = { "_foo", "_012foo", "_@bar", "BAZ",  "_&ban", "__jar", "_*zip", "_-zap" };
+        final String pass_types[] = { "A-Z" };
+        checkFirstCharacterTypesRulePrefixInternal(original, expected, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixUpperwording()
+    {
+        final String original[] = { "foo",  "012foo",  "@bar",  "BAZ",  "&ban",  "_jar",  "*zip",  "-zap"  };
+        final String expected[] = { "-foo", "012foo",  "-@bar", "BAZ",  "-&ban", "_jar",  "-*zip", "--zap" };
+        final String pass_types[] = { "A-Z", "0-9" };
+        checkFirstCharacterTypesRulePrefixInternal(original, expected, "-", pass_types, "_");
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixWording()
+    {
+        final String original[] = { "foo",  "012foo",  "@bar",  "BAZ",  "&ban",  "_jar",  "*zip",  "-zap"  };
+        final String expected[] = { "foo",  "012foo",  "$@bar", "BAZ",  "$&ban", "_jar",  "$*zip", "$-zap" };
+        final String pass_types[] = { "a-z", "A-Z", "0-9" };
+        checkFirstCharacterTypesRulePrefixInternal(original, expected, "$", pass_types, "_");
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleEmptyPrefix()
+    {
+        final String original[] = { "foo" };
+        final String pass_types[] = {};
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkFirstCharacterTypesRulePrefixInternal(original, original, "", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleLongPrefix()
+    {
+        final String original[] = { "foo" };
+        final String pass_types[] = {};
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkFirstCharacterTypesRulePrefixInternal(original, original, "__", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleEmptyReplace()
+    {
+        final String original[] = { "foo" };
+        final String pass_types[] = {};
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkFirstCharacterTypesRuleReplaceInternal(original, original, "", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleLongReplace()
+    {
+        final String original[] = { "foo" };
+        final String pass_types[] = {};
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkFirstCharacterTypesRuleReplaceInternal(original, original, "__", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixUnknownFirst()
+    {
+        final String original[] = { "foo" };
+        final String pass_types[] = { "some_unknown_type" };
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkFirstCharacterTypesRulePrefixInternal(original, original, "_", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRulePrefixForbiddenCharSequence()
+    {
+        final String original[] = { "foo" };
+        final String pass_types[] = {};
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkFirstCharacterTypesRulePrefixInternal(original, original, "\\E", pass_types);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleBothReplacePrefix()
+    {
+        HashMap<String, Object> parameters = new HashMap<>();
+        parameters.put("rule", "first_character_types");
+        parameters.put("replace", "_");
+        parameters.put("prefix", "_");
+        ConfigSource config = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.copyOf(parameters)));
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        renameAndCheckSchema(config, new String[0], new String[0]);
+    }
+
+    @Test
+    public void checkFirstCharacterTypesRuleNeitherReplacePrefix()
+    {
+        HashMap<String, Object> parameters = new HashMap<>();
+        parameters.put("rule", "first_character_types");
+        ConfigSource config = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.copyOf(parameters)));
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        renameAndCheckSchema(config, new String[0], new String[0]);
+    }
+
+    private void checkFirstCharacterTypesRuleReplaceInternal(
+            final String original[],
+            final String expected[],
+            final String replace,
+            final String pass_types[]) {
+        checkFirstCharacterTypesRuleReplaceInternal(original, expected, replace, pass_types, DEFAULT);
+    }
+
+    private void checkFirstCharacterTypesRuleReplaceInternal(
+            final String original[],
+            final String expected[],
+            final String replace,
+            final String pass_types[],
+            final String pass_characters)
+    {
+        HashMap<String, Object> parameters = new HashMap<>();
+        parameters.put("rule", "first_character_types");
+        if (pass_types.length > 0) {
+            parameters.put("pass_types", Arrays.asList(pass_types));
+        }
+        if (!pass_characters.equals(DEFAULT)) {
+            parameters.put("pass_characters", pass_characters);
+        }
+        if (!replace.equals(DEFAULT)) {
+            parameters.put("replace", replace);
+        }
+        ConfigSource config = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.copyOf(parameters)));
+        renameAndCheckSchema(config, original, expected);
+    }
+
+    private void checkFirstCharacterTypesRulePrefixInternal(
+            final String original[],
+            final String expected[],
+            final String prefix,
+            final String pass_types[]) {
+        checkFirstCharacterTypesRulePrefixInternal(original, expected, prefix, pass_types, DEFAULT);
+    }
+
+    private void checkFirstCharacterTypesRulePrefixInternal(
+            final String original[],
+            final String expected[],
+            final String prefix,
+            final String pass_types[],
+            final String pass_characters)
+    {
+        HashMap<String, Object> parameters = new HashMap<>();
+        parameters.put("rule", "first_character_types");
+        if (pass_types.length > 0) {
+            parameters.put("pass_types", Arrays.asList(pass_types));
+        }
+        if (!pass_characters.equals(DEFAULT)) {
+            parameters.put("pass_characters", pass_characters);
+        }
+        if (!prefix.equals(DEFAULT)) {
+            parameters.put("prefix", prefix);
+        }
+        ConfigSource config = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.copyOf(parameters)));
+        renameAndCheckSchema(config, original, expected);
+    }
+
+    public void checkUniqueNumberSuffixRuleEmptyDelimiter()
+    {
+        final String columnNames[] = { "c" };
+        try {
+            checkUniqueNumberSuffixRuleInternal(columnNames, columnNames, "");
+        } catch (Throwable t) {
+            assertTrue(t instanceof ConfigException);
+        }
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRuleLongDelimiter()
+    {
+        final String columnNames[] = { "c" };
+        try {
+            checkUniqueNumberSuffixRuleInternal(columnNames, columnNames, "__");
+        } catch (Throwable t) {
+            assertTrue(t instanceof ConfigException);
+        }
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRuleDigitDelimiter()
+    {
+        final String columnNames[] = { "c" };
+        try {
+            checkUniqueNumberSuffixRuleInternal(columnNames, columnNames, "2");
+        } catch (Throwable t) {
+            assertTrue(t instanceof ConfigException);
+        }
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRuleShortMaxLength()
+    {
+        final String columnNames[] = { "c" };
+        try {
+            checkUniqueNumberSuffixRuleInternal(columnNames, columnNames, DEFAULT, -1, 7);
+        } catch (Throwable t) {
+            assertTrue(t instanceof ConfigException);
+        }
+    }
+
+    // TODO(dmikurube): Test a nil/null delimiter in "unique".
+    // - rule: unique
+    //   delimiter:
+
+    @Test
+    public void checkUniqueNumberSuffixRule0()
+    {
+        final String originalColumnNames[] = { "a", "b", "c", "d", "e" };
+        final String expectedColumnNames[] = { "a", "b", "c", "d", "e" };
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, expectedColumnNames);
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRule1()
+    {
+        final String originalColumnNames[] = { "c", "c",   "c1", "c2", "c2"   };
+        final String expectedColumnNames[] = { "c", "c_2", "c1", "c2", "c2_2" };
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, expectedColumnNames);
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRule2()
+    {
+        final String originalColumnNames[] = { "c", "c",   "c_1", "c_3", "c"   };
+        final String expectedColumnNames[] = { "c", "c_2", "c_1", "c_3", "c_4" };
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, expectedColumnNames);
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRule3()
+    {
+        final String originalColumnNames[] = {
+            "c", "c",   "c",   "c",   "c",   "c",   "c",   "c",   "c",   "c",    "c_1", "c_1"   };
+        final String expectedColumnNames[] = {
+            "c", "c_2", "c_3", "c_4", "c_5", "c_6", "c_7", "c_8", "c_9", "c_10", "c_1", "c_1_2" };
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, expectedColumnNames);
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRule4DifferentDelimiter()
+    {
+        final String originalColumnNames[] = { "c", "c",   "c1", "c2", "c2"   };
+        final String expectedColumnNames[] = { "c", "c-2", "c1", "c2", "c2-2" };
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, expectedColumnNames, "-");
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRule5Digits()
+    {
+        final String originalColumnNames[] = { "c", "c",      "c1", "c2", "c2"   };
+        final String expectedColumnNames[] = { "c", "c_0002", "c1", "c2", "c2_0002" };
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, expectedColumnNames, DEFAULT, 4, -1);
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRule6MaxLength1()
+    {
+        final String originalColumnNames[] = { "column", "column",   "column_1", "column_2", "column_2" };
+        final String expectedColumnNames[] = { "column", "column_3", "column_1", "column_2", "column_4" };
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, expectedColumnNames, DEFAULT, -1, 8);
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRule7()
+    {
+        final String originalColumnNames[] = { "column", "column",   "column_2", "column_3" };
+        final String expectedColumnNames[] = { "column", "column_4", "column_2", "column_3" };
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, expectedColumnNames, DEFAULT, -1, 8);
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRule8MaxLength2()
+    {
+        final String originalColumnNames[] = {
+            "column",   "colum",    "column",   "colum",    "column",   "colum",    "column",   "colum",    "column",
+            "colum",    "column",   "colum",    "column",   "colum",    "column",   "colum",    "column",   "colum",
+            "column",   "colum",    "column",   "colum"    };
+        final String expectedColumnNames[] = {
+            "column",   "colum",    "column_2", "colum_2",  "column_3", "colum_3",  "column_4", "colum_4",  "column_5",
+            "colum_5",  "column_6", "colum_6",  "column_7", "colum_7",  "column_8", "colum_8",  "column_9", "colum_9",
+            "colum_10", "colum_11", "colum_12", "colum_13" };
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, expectedColumnNames, DEFAULT, -1, 8);
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRule9MaxLength3()
+    {
+        final String originalColumnNames[] = {
+            "column", "column",   "column",   "column",   "column",   "column",   "column",   "column",   "column",
+            "colum",  "colum",    "colum",    "colum",    "colum",    "colum",    "colum",    "colum",
+            "column",   "colum",   "column",   "colum",    "column"   };
+        final String expectedColumnNames[] = {
+            "column", "column_2", "column_3", "column_4", "column_5", "column_6", "column_7", "column_8", "column_9",
+            "colum",  "colum_2",  "colum_3",  "colum_4",  "colum_5",  "colum_6",  "colum_7",  "colum_8",
+            "colum_10", "colum_9", "colum_11", "colum_12", "colum_13" };
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, expectedColumnNames, DEFAULT, -1, 8);
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRule10EsteemOriginalNames()
+    {
+        final String originalColumnNames[] = { "c", "c",   "c_2" };
+        final String expectedColumnNames[] = { "c", "c_3", "c_2" };
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, expectedColumnNames, DEFAULT, -1, -1);
+    }
+
+    @Test
+    public void checkUniqueNumberSuffixRuleNegativeLength()
+    {
+        final String originalColumnNames[] = { "column" };
+        exception.expect(ConfigException.class);
+        // TODO(dmikurube): Except "Caused by": exception.expectCause(instanceOf(JsonMappingException.class));
+        // Needs to import org.hamcrest.Matchers... in addition to org.junit...
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames, originalColumnNames, DEFAULT, -1, -2);
+    }
+
+    private void checkUniqueNumberSuffixRuleInternal(
+            final String originalColumnNames[],
+            final String expectedColumnNames[]) {
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames,
+                                            expectedColumnNames,
+                                            DEFAULT,
+                                            -1,
+                                            -1);
+    }
+
+    private void checkUniqueNumberSuffixRuleInternal(
+            final String originalColumnNames[],
+            final String expectedColumnNames[],
+            String delimiter) {
+        checkUniqueNumberSuffixRuleInternal(originalColumnNames,
+                                            expectedColumnNames,
+                                            delimiter,
+                                            -1,
+                                            -1);
+    }
+
+    private void checkUniqueNumberSuffixRuleInternal(
+            final String originalColumnNames[],
+            final String expectedColumnNames[],
+            String delimiter,
+            int digits,
+            int max_length)
+    {
+        Schema.Builder originalSchemaBuilder = Schema.builder();
+        for (String originalColumnName : originalColumnNames) {
+            originalSchemaBuilder.add(originalColumnName, STRING);
+        }
+        final Schema ORIGINAL_SCHEMA = originalSchemaBuilder.build();
+
+        HashMap<String, Object> parameters = new HashMap<>();
+        parameters.put("rule", "unique_number_suffix");
+        if (!delimiter.equals(DEFAULT)) {
+            parameters.put("delimiter", delimiter);
+        }
+        if (digits >= 0) {
+            parameters.put("digits", digits);
+        }
+        if (max_length != -1) {
+            parameters.put("max_length", max_length);
+        }
+        ConfigSource pluginConfig = Exec.newConfigSource().set("rules",
+                ImmutableList.of(ImmutableMap.copyOf(parameters)));
+
+        filter.transaction(pluginConfig, ORIGINAL_SCHEMA, new FilterPlugin.Control() {
+            @Override
+            public void run(TaskSource task, Schema newSchema)
+            {
+                ArrayList<String> resolvedColumnNamesList = new ArrayList<>(newSchema.size());
+                for (Column resolvedColumn : newSchema.getColumns()) {
+                    resolvedColumnNamesList.add(resolvedColumn.getName());
+                }
+                String[] resolvedColumnNames = Iterables.toArray(resolvedColumnNamesList, String.class);
+                assertEquals(expectedColumnNames, resolvedColumnNames);
+                for (int i = 0; i < expectedColumnNames.length; ++i) {
+                    Column original = ORIGINAL_SCHEMA.getColumn(i);
+                    Column resolved = newSchema.getColumn(i);
+                    assertEquals(original.getType(), resolved.getType());
+                }
+            }
+        });
+    }
+
+    private Schema makeSchema(final String columnNames[])
+    {
+        Schema.Builder builder = new Schema.Builder();
+        for (String columnName : columnNames) {
+            builder.add(columnName, STRING);
+        }
+        return builder.build();
+    }
+
+    private void renameAndCheckSchema(ConfigSource config,
+                                      final String original[],
+                                      final String expected[])
+    {
+        final Schema originalSchema = makeSchema(original);
+        filter.transaction(config, originalSchema, new FilterPlugin.Control() {
+            @Override
+            public void run(TaskSource task, Schema renamedSchema)
+            {
+                assertEquals(originalSchema.getColumnCount(), renamedSchema.getColumnCount());
+                assertEquals(expected.length, renamedSchema.getColumnCount());
+                for (int i = 0; i < renamedSchema.getColumnCount(); ++i) {
+                    assertEquals(originalSchema.getColumnType(i), renamedSchema.getColumnType(i));
+                    assertEquals(expected[i], renamedSchema.getColumnName(i));
+                }
+            }
+        });
+    }
 }