Java 类org.apache.hadoop.fs.shell.FsCommand 实例源码

项目：hadoop 文件：TestFsShellReturnCode.java

/**
 * Tests valid and invalid group arguments to chgrp.
 */
@Test
public void testChgrpGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chgrp = new FsShellPermissions.Chgrp() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chgrp.setConf(new Configuration());

  // The following are valid (no exception expected).
  chgrp.run("group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chgrp, "Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chgrp, ":gr#oup", "/path");
  assertIllegalArguments(chgrp, ":gr%oup", "/path");
}

项目：big-c 文件：TestFsShellReturnCode.java

/**
 * Tests valid and invalid group arguments to chgrp.
 */
@Test
public void testChgrpGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chgrp = new FsShellPermissions.Chgrp() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chgrp.setConf(new Configuration());

  // The following are valid (no exception expected).
  chgrp.run("group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chgrp, "Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chgrp, ":gr#oup", "/path");
  assertIllegalArguments(chgrp, ":gr%oup", "/path");
}

项目：hadoop-2.6.0-cdh5.4.3 文件：TestFsShellReturnCode.java

/**
 * Tests valid and invalid group arguments to chgrp.
 */
@Test
public void testChgrpGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chgrp = new FsShellPermissions.Chgrp() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chgrp.setConf(new Configuration());

  // The following are valid (no exception expected).
  chgrp.run("group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chgrp, "Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chgrp, ":gr#oup", "/path");
  assertIllegalArguments(chgrp, ":gr%oup", "/path");
}

项目：hadoop-TCP 文件：TestFsShellReturnCode.java

/**
 * Tests valid and invalid group arguments to chgrp.
 */
@Test
public void testChgrpGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chgrp = new FsShellPermissions.Chgrp() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chgrp.setConf(new Configuration());

  // The following are valid (no exception expected).
  chgrp.run("group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chgrp, "Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chgrp, ":gr#oup", "/path");
  assertIllegalArguments(chgrp, ":gr%oup", "/path");
}

项目：hardfs 文件：TestFsShellReturnCode.java

/**
 * Tests valid and invalid group arguments to chgrp.
 */
@Test
public void testChgrpGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chgrp = new FsShellPermissions.Chgrp() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chgrp.setConf(new Configuration());

  // The following are valid (no exception expected).
  chgrp.run("group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chgrp, "Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chgrp, ":gr#oup", "/path");
  assertIllegalArguments(chgrp, ":gr%oup", "/path");
}

项目：hadoop-on-lustre2 文件：TestFsShellReturnCode.java

/**
 * Tests valid and invalid group arguments to chgrp.
 */
@Test
public void testChgrpGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chgrp = new FsShellPermissions.Chgrp() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chgrp.setConf(new Configuration());

  // The following are valid (no exception expected).
  chgrp.run("group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chgrp, "Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chgrp, ":gr#oup", "/path");
  assertIllegalArguments(chgrp, ":gr%oup", "/path");
}

项目：hadoop-oss 文件：FsShell.java

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(FsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}

项目：hadoop-oss 文件：TestFsShellReturnCode.java

private void testChownUserAndGroupValidity(boolean enableWarning) {
  Configuration conf = new Configuration();
  conf.setBoolean(
      HADOOP_SHELL_MISSING_DEFAULT_FS_WARNING_KEY, enableWarning);
  FsCommand chown = new FakeChown();
  chown.setConf(conf);

  // The following are valid (no exception expected).
  chown.run("user", "/path");
  chown.run("user:group", "/path");
  chown.run(":group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chown, "User With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:group", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:Group With Spaces",
    "/path");
  assertValidArgumentsOnWindows(chown, "user:Group With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, ":Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chown, "us!er", "/path");
  assertIllegalArguments(chown, "us^er", "/path");
  assertIllegalArguments(chown, "user:gr#oup", "/path");
  assertIllegalArguments(chown, "user:gr%oup", "/path");
  assertIllegalArguments(chown, ":gr#oup", "/path");
  assertIllegalArguments(chown, ":gr%oup", "/path");
}

项目：hadoop-oss 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered
 * invalid.  The expectation is that the command will throw
 * IllegalArgumentException.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertIllegalArguments(FsCommand cmd, String... args) {
  try {
    cmd.run(args);
    fail("Expected IllegalArgumentException from args: " +
      Arrays.toString(args));
  } catch (IllegalArgumentException e) {
  }
}

项目：hadoop-oss 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered valid
 * on Windows, but invalid elsewhere.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertValidArgumentsOnWindows(FsCommand cmd,
    String... args) {
  if (Shell.WINDOWS) {
    cmd.run(args);
  } else {
    assertIllegalArguments(cmd, args);
  }
}

项目：hdfs-shell 文件：ContextCommandsTest.java

@Test
@Ignore
public void generateMethods() {
    final CommandFactory commandFactory = new CommandFactory(new Configuration());
    FsCommand.registerCommands(commandFactory);
    final String[] names = commandFactory.getNames();
    final String collect = Arrays.stream(names).map(item -> "\"" + item.replace("-", "") + "\"").collect(Collectors.joining(","));
    System.out.println(collect);
    Arrays.stream(names).map(commandFactory::getInstance).forEach(item -> {
        String description = "";
        final String[] sentences = item.getDescription().split("\\.");
        if (sentences.length == 0) {
            description = item.getDescription();
        } else {
            description = sentences[0] + ".";
        }


        String cliCommand = String.format("@CliCommand(value = {\"%s\", \"hdfs dfs -%s\"}, help = \"%s\")", item.getCommandName(), item.getCommandName(), description);
        String content = String.format("    public String %s(\n" +
                "            @CliOption(key = {\"\"}, help = \"%s\") String path\n" +
                "    ) {\n" +
                "        return runCommand(\"%s\", path);\n" +
                "    }\n", item.getCommandName(), description, item.getCommandName());

        System.out.println(cliCommand);
        System.out.println(content);

        System.out.println();

    });

}

项目：hadoop 文件：FsShell.java

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(FsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}

项目：hadoop 文件：TestFsShellReturnCode.java

/**
 * Tests combinations of valid and invalid user and group arguments to chown.
 */
@Test
public void testChownUserAndGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chown = new FsShellPermissions.Chown() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chown.setConf(new Configuration());

  // The following are valid (no exception expected).
  chown.run("user", "/path");
  chown.run("user:group", "/path");
  chown.run(":group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chown, "User With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:group", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:Group With Spaces",
    "/path");
  assertValidArgumentsOnWindows(chown, "user:Group With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, ":Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chown, "us!er", "/path");
  assertIllegalArguments(chown, "us^er", "/path");
  assertIllegalArguments(chown, "user:gr#oup", "/path");
  assertIllegalArguments(chown, "user:gr%oup", "/path");
  assertIllegalArguments(chown, ":gr#oup", "/path");
  assertIllegalArguments(chown, ":gr%oup", "/path");
}

项目：hadoop 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered
 * invalid.  The expectation is that the command will throw
 * IllegalArgumentException.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertIllegalArguments(FsCommand cmd, String... args) {
  try {
    cmd.run(args);
    fail("Expected IllegalArgumentException from args: " +
      Arrays.toString(args));
  } catch (IllegalArgumentException e) {
  }
}

项目：hadoop 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered valid
 * on Windows, but invalid elsewhere.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertValidArgumentsOnWindows(FsCommand cmd,
    String... args) {
  if (Shell.WINDOWS) {
    cmd.run(args);
  } else {
    assertIllegalArguments(cmd, args);
  }
}

项目：aliyun-oss-hadoop-fs 文件：FsShell.java

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(FsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}

项目：aliyun-oss-hadoop-fs 文件：TestFsShellReturnCode.java

private void testChownUserAndGroupValidity(boolean enableWarning) {
  Configuration conf = new Configuration();
  conf.setBoolean(
      HADOOP_SHELL_MISSING_DEFAULT_FS_WARNING_KEY, enableWarning);
  FsCommand chown = new FakeChown();
  chown.setConf(conf);

  // The following are valid (no exception expected).
  chown.run("user", "/path");
  chown.run("user:group", "/path");
  chown.run(":group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chown, "User With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:group", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:Group With Spaces",
    "/path");
  assertValidArgumentsOnWindows(chown, "user:Group With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, ":Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chown, "us!er", "/path");
  assertIllegalArguments(chown, "us^er", "/path");
  assertIllegalArguments(chown, "user:gr#oup", "/path");
  assertIllegalArguments(chown, "user:gr%oup", "/path");
  assertIllegalArguments(chown, ":gr#oup", "/path");
  assertIllegalArguments(chown, ":gr%oup", "/path");
}

项目：aliyun-oss-hadoop-fs 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered
 * invalid.  The expectation is that the command will throw
 * IllegalArgumentException.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertIllegalArguments(FsCommand cmd, String... args) {
  try {
    cmd.run(args);
    fail("Expected IllegalArgumentException from args: " +
      Arrays.toString(args));
  } catch (IllegalArgumentException e) {
  }
}

项目：aliyun-oss-hadoop-fs 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered valid
 * on Windows, but invalid elsewhere.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertValidArgumentsOnWindows(FsCommand cmd,
    String... args) {
  if (Shell.WINDOWS) {
    cmd.run(args);
  } else {
    assertIllegalArguments(cmd, args);
  }
}

项目：big-c 文件：FsShell.java

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(FsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}

项目：big-c 文件：TestFsShellReturnCode.java

/**
 * Tests combinations of valid and invalid user and group arguments to chown.
 */
@Test
public void testChownUserAndGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chown = new FsShellPermissions.Chown() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chown.setConf(new Configuration());

  // The following are valid (no exception expected).
  chown.run("user", "/path");
  chown.run("user:group", "/path");
  chown.run(":group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chown, "User With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:group", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:Group With Spaces",
    "/path");
  assertValidArgumentsOnWindows(chown, "user:Group With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, ":Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chown, "us!er", "/path");
  assertIllegalArguments(chown, "us^er", "/path");
  assertIllegalArguments(chown, "user:gr#oup", "/path");
  assertIllegalArguments(chown, "user:gr%oup", "/path");
  assertIllegalArguments(chown, ":gr#oup", "/path");
  assertIllegalArguments(chown, ":gr%oup", "/path");
}

项目：big-c 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered
 * invalid.  The expectation is that the command will throw
 * IllegalArgumentException.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertIllegalArguments(FsCommand cmd, String... args) {
  try {
    cmd.run(args);
    fail("Expected IllegalArgumentException from args: " +
      Arrays.toString(args));
  } catch (IllegalArgumentException e) {
  }
}

项目：big-c 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered valid
 * on Windows, but invalid elsewhere.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertValidArgumentsOnWindows(FsCommand cmd,
    String... args) {
  if (Shell.WINDOWS) {
    cmd.run(args);
  } else {
    assertIllegalArguments(cmd, args);
  }
}

项目：hadoop-2.6.0-cdh5.4.3 文件：FsShell.java

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(FsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}

项目：hadoop-2.6.0-cdh5.4.3 文件：TestFsShellReturnCode.java

/**
 * Tests combinations of valid and invalid user and group arguments to chown.
 */
@Test
public void testChownUserAndGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chown = new FsShellPermissions.Chown() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chown.setConf(new Configuration());

  // The following are valid (no exception expected).
  chown.run("user", "/path");
  chown.run("user:group", "/path");
  chown.run(":group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chown, "User With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:group", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:Group With Spaces",
    "/path");
  assertValidArgumentsOnWindows(chown, "user:Group With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, ":Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chown, "us!er", "/path");
  assertIllegalArguments(chown, "us^er", "/path");
  assertIllegalArguments(chown, "user:gr#oup", "/path");
  assertIllegalArguments(chown, "user:gr%oup", "/path");
  assertIllegalArguments(chown, ":gr#oup", "/path");
  assertIllegalArguments(chown, ":gr%oup", "/path");
}

项目：hadoop-2.6.0-cdh5.4.3 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered
 * invalid.  The expectation is that the command will throw
 * IllegalArgumentException.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertIllegalArguments(FsCommand cmd, String... args) {
  try {
    cmd.run(args);
    fail("Expected IllegalArgumentException from args: " +
      Arrays.toString(args));
  } catch (IllegalArgumentException e) {
  }
}

项目：hadoop-2.6.0-cdh5.4.3 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered valid
 * on Windows, but invalid elsewhere.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertValidArgumentsOnWindows(FsCommand cmd,
    String... args) {
  if (Shell.WINDOWS) {
    cmd.run(args);
  } else {
    assertIllegalArguments(cmd, args);
  }
}

项目：hadoop-plus 文件：FsShell.java

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(FsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}

项目：hops 文件：FsShell.java

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(FsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}

项目：hops 文件：TestFsShellReturnCode.java

private void testChownUserAndGroupValidity(boolean enableWarning) {
  Configuration conf = new Configuration();
  conf.setBoolean(
      HADOOP_SHELL_MISSING_DEFAULT_FS_WARNING_KEY, enableWarning);
  FsCommand chown = new FakeChown();
  chown.setConf(conf);

  // The following are valid (no exception expected).
  chown.run("user", "/path");
  chown.run("user:group", "/path");
  chown.run(":group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chown, "User With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:group", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:Group With Spaces",
    "/path");
  assertValidArgumentsOnWindows(chown, "user:Group With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, ":Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chown, "us!er", "/path");
  assertIllegalArguments(chown, "us^er", "/path");
  assertIllegalArguments(chown, "user:gr#oup", "/path");
  assertIllegalArguments(chown, "user:gr%oup", "/path");
  assertIllegalArguments(chown, ":gr#oup", "/path");
  assertIllegalArguments(chown, ":gr%oup", "/path");
}

项目：hops 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered
 * invalid.  The expectation is that the command will throw
 * IllegalArgumentException.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertIllegalArguments(FsCommand cmd, String... args) {
  try {
    cmd.run(args);
    fail("Expected IllegalArgumentException from args: " +
      Arrays.toString(args));
  } catch (IllegalArgumentException e) {
  }
}

项目：hops 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered valid
 * on Windows, but invalid elsewhere.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertValidArgumentsOnWindows(FsCommand cmd,
    String... args) {
  if (Shell.WINDOWS) {
    cmd.run(args);
  } else {
    assertIllegalArguments(cmd, args);
  }
}

项目：hadoop-TCP 文件：FsShell.java

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(FsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}

项目：hadoop-TCP 文件：TestFsShellReturnCode.java

/**
 * Tests combinations of valid and invalid user and group arguments to chown.
 */
@Test
public void testChownUserAndGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chown = new FsShellPermissions.Chown() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chown.setConf(new Configuration());

  // The following are valid (no exception expected).
  chown.run("user", "/path");
  chown.run("user:group", "/path");
  chown.run(":group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chown, "User With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:group", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:Group With Spaces",
    "/path");
  assertValidArgumentsOnWindows(chown, "user:Group With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, ":Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chown, "us!er", "/path");
  assertIllegalArguments(chown, "us^er", "/path");
  assertIllegalArguments(chown, "user:gr#oup", "/path");
  assertIllegalArguments(chown, "user:gr%oup", "/path");
  assertIllegalArguments(chown, ":gr#oup", "/path");
  assertIllegalArguments(chown, ":gr%oup", "/path");
}

项目：hadoop-TCP 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered
 * invalid.  The expectation is that the command will throw
 * IllegalArgumentException.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertIllegalArguments(FsCommand cmd, String... args) {
  try {
    cmd.run(args);
    fail("Expected IllegalArgumentException from args: " +
      Arrays.toString(args));
  } catch (IllegalArgumentException e) {
  }
}

项目：hadoop-TCP 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered valid
 * on Windows, but invalid elsewhere.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertValidArgumentsOnWindows(FsCommand cmd,
    String... args) {
  if (Shell.WINDOWS) {
    cmd.run(args);
  } else {
    assertIllegalArguments(cmd, args);
  }
}

项目：hardfs 文件：FsShell.java

protected void registerCommands(CommandFactory factory) {
  // TODO: DFSAdmin subclasses FsShell so need to protect the command
  // registration.  This class should morph into a base class for
  // commands, and then this method can be abstract
  if (this.getClass().equals(FsShell.class)) {
    factory.registerCommands(FsCommand.class);
  }
}

项目：hardfs 文件：TestFsShellReturnCode.java

/**
 * Tests combinations of valid and invalid user and group arguments to chown.
 */
@Test
public void testChownUserAndGroupValidity() {
  // This test only covers argument parsing, so override to skip processing.
  FsCommand chown = new FsShellPermissions.Chown() {
    @Override
    protected void processArgument(PathData item) {
    }
  };
  chown.setConf(new Configuration());

  // The following are valid (no exception expected).
  chown.run("user", "/path");
  chown.run("user:group", "/path");
  chown.run(":group", "/path");

  // The following are valid only on Windows.
  assertValidArgumentsOnWindows(chown, "User With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:group", "/path");
  assertValidArgumentsOnWindows(chown, "User With Spaces:Group With Spaces",
    "/path");
  assertValidArgumentsOnWindows(chown, "user:Group With Spaces", "/path");
  assertValidArgumentsOnWindows(chown, ":Group With Spaces", "/path");

  // The following are invalid (exception expected).
  assertIllegalArguments(chown, "us!er", "/path");
  assertIllegalArguments(chown, "us^er", "/path");
  assertIllegalArguments(chown, "user:gr#oup", "/path");
  assertIllegalArguments(chown, "user:gr%oup", "/path");
  assertIllegalArguments(chown, ":gr#oup", "/path");
  assertIllegalArguments(chown, ":gr%oup", "/path");
}

项目：hardfs 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered
 * invalid.  The expectation is that the command will throw
 * IllegalArgumentException.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertIllegalArguments(FsCommand cmd, String... args) {
  try {
    cmd.run(args);
    fail("Expected IllegalArgumentException from args: " +
      Arrays.toString(args));
  } catch (IllegalArgumentException e) {
  }
}

项目：hardfs 文件：TestFsShellReturnCode.java

/**
 * Asserts that for the given command, the given arguments are considered valid
 * on Windows, but invalid elsewhere.
 * 
 * @param cmd FsCommand to check
 * @param args String... arguments to check
 */
private static void assertValidArgumentsOnWindows(FsCommand cmd,
    String... args) {
  if (Shell.WINDOWS) {
    cmd.run(args);
  } else {
    assertIllegalArguments(cmd, args);
  }
}