HDFS-5858. Refactor common ACL test cases to be run through multiple FileSystem implementations. Contributed by Chris Nauroth.

git-svn-id: https://svn.apache.org/repos/asf/hadoop/common/branches/HDFS-4685@1563325 13f79535-47bb-0310-9956-ffa450edef68

hadoop-hdfs-project/hadoop-hdfs/CHANGES-HDFS-4685.txt

@@ -53,6 +53,9 @@ HDFS-4685 (Unreleased)
     HDFS-5614. NameNode: implement handling of ACLs in combination with
     snapshots. (cnauroth)
 
+    HDFS-5858. Refactor common ACL test cases to be run through multiple
+    FileSystem implementations. (cnauroth)
+
   OPTIMIZATIONS
 
   BUG FIXES

hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/FSAclBaseTest.java

@@ -0,0 +1,819 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hdfs.server.namenode;
+
+import static org.apache.hadoop.hdfs.server.namenode.AclTestHelpers.*;
+import static org.apache.hadoop.fs.permission.AclEntryScope.*;
+import static org.apache.hadoop.fs.permission.AclEntryType.*;
+import static org.apache.hadoop.fs.permission.FsAction.*;
+import static org.junit.Assert.*;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.List;
+
+import org.apache.hadoop.fs.FileSystem;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.fs.permission.AclEntry;
+import org.apache.hadoop.fs.permission.AclStatus;
+import org.apache.hadoop.fs.permission.FsPermission;
+import org.apache.hadoop.hdfs.MiniDFSCluster;
+import org.apache.hadoop.hdfs.protocol.AclException;
+import org.apache.hadoop.io.IOUtils;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.google.common.collect.Lists;
+
+/**
+ * Tests NameNode interaction for all ACL modification APIs.  This test suite
+ * also covers interaction of setPermission with inodes that have ACLs.
+ */
+public abstract class FSAclBaseTest {
+
+  protected static MiniDFSCluster cluster;
+  protected static FileSystem fs;
+  private static int pathCount = 0;
+  private static Path path;
+
+  @AfterClass
+  public static void shutdown() throws Exception {
+    IOUtils.cleanup(null, fs);
+    if (cluster != null) {
+      cluster.shutdown();
+    }
+  }
+
+  @Before
+  public void setUp() {
+    pathCount += 1;
+    path = new Path("/p" + pathCount);
+  }
+
+  @Test
+  public void testModifyAclEntries() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
+      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE));
+    fs.modifyAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, MASK, READ_EXECUTE),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)02750);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testModifyAclEntriesOnlyAccess() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0640));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE));
+    fs.setAcl(path, aclSpec);
+    aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, "foo", READ_EXECUTE));
+    fs.modifyAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
+    assertPermission((short)02750);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testModifyAclEntriesOnlyDefault() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    aclSpec = Lists.newArrayList(
+      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE));
+    fs.modifyAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, MASK, READ_EXECUTE),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)02750);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testModifyAclEntriesMinimal() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0640));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, "foo", READ_WRITE));
+    fs.modifyAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", READ_WRITE),
+      aclEntry(ACCESS, GROUP, READ) }, returned);
+    assertPermission((short)02660);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testModifyAclEntriesMinimalDefault() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, OTHER, NONE));
+    fs.modifyAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)02750);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testModifyAclEntriesCustomMask() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0640));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, MASK, NONE));
+    fs.modifyAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ) }, returned);
+    assertPermission((short)02600);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testModifyAclEntriesStickyBit() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
+      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE));
+    fs.modifyAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, MASK, READ_EXECUTE),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)03750);
+    assertAclFeature(true);
+  }
+
+  @Test(expected=FileNotFoundException.class)
+  public void testModifyAclEntriesPathNotFound() throws IOException {
+    // Path has not been created.
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE));
+    fs.modifyAclEntries(path, aclSpec);
+  }
+
+  @Test(expected=AclException.class)
+  public void testModifyAclEntriesDefaultOnFile() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0640));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.modifyAclEntries(path, aclSpec);
+  }
+
+  @Test
+  public void testRemoveAclEntries() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, "foo"),
+      aclEntry(DEFAULT, USER, "foo"));
+    fs.removeAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, MASK, READ_EXECUTE),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)02750);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testRemoveAclEntriesOnlyAccess() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0640));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, USER, "bar", READ_WRITE),
+      aclEntry(ACCESS, GROUP, READ_WRITE),
+      aclEntry(ACCESS, OTHER, NONE));
+    fs.setAcl(path, aclSpec);
+    aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, "foo"));
+    fs.removeAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "bar", READ_WRITE),
+      aclEntry(ACCESS, GROUP, READ_WRITE) }, returned);
+    assertPermission((short)02760);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testRemoveAclEntriesOnlyDefault() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL),
+      aclEntry(DEFAULT, USER, "bar", READ_EXECUTE));
+    fs.setAcl(path, aclSpec);
+    aclSpec = Lists.newArrayList(
+      aclEntry(DEFAULT, USER, "foo"));
+    fs.removeAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, USER, "bar", READ_EXECUTE),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, MASK, READ_EXECUTE),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)02750);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testRemoveAclEntriesMinimal() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0760));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_WRITE),
+      aclEntry(ACCESS, OTHER, NONE));
+    fs.setAcl(path, aclSpec);
+    aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, "foo"),
+      aclEntry(ACCESS, MASK));
+    fs.removeAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] { }, returned);
+    assertPermission((short)0760);
+    assertAclFeature(false);
+  }
+
+
+  @Test
+  public void testRemoveAclEntriesMinimalDefault() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, "foo"),
+      aclEntry(ACCESS, MASK),
+      aclEntry(DEFAULT, USER, "foo"),
+      aclEntry(DEFAULT, MASK));
+    fs.removeAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)02750);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testRemoveAclEntriesStickyBit() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, "foo"),
+      aclEntry(DEFAULT, USER, "foo"));
+    fs.removeAclEntries(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, MASK, READ_EXECUTE),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)03750);
+    assertAclFeature(true);
+  }
+
+  @Test(expected=FileNotFoundException.class)
+  public void testRemoveAclEntriesPathNotFound() throws IOException {
+    // Path has not been created.
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, "foo"));
+    fs.removeAclEntries(path, aclSpec);
+  }
+
+  @Test
+  public void testRemoveDefaultAcl() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    fs.removeDefaultAcl(path);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
+    assertPermission((short)02770);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testRemoveDefaultAclOnlyAccess() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0640));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE));
+    fs.setAcl(path, aclSpec);
+    fs.removeDefaultAcl(path);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
+    assertPermission((short)02770);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testRemoveDefaultAclOnlyDefault() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    fs.removeDefaultAcl(path);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] { }, returned);
+    assertPermission((short)0750);
+    assertAclFeature(false);
+  }
+
+  @Test
+  public void testRemoveDefaultAclMinimal() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    fs.removeDefaultAcl(path);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] { }, returned);
+    assertPermission((short)0750);
+    assertAclFeature(false);
+  }
+
+  @Test
+  public void testRemoveDefaultAclStickyBit() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    fs.removeDefaultAcl(path);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
+    assertPermission((short)03770);
+    assertAclFeature(true);
+  }
+
+  @Test(expected=FileNotFoundException.class)
+  public void testRemoveDefaultAclPathNotFound() throws IOException {
+    // Path has not been created.
+    fs.removeDefaultAcl(path);
+  }
+
+  @Test
+  public void testRemoveAcl() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    fs.removeAcl(path);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] { }, returned);
+    assertPermission((short)0750);
+    assertAclFeature(false);
+  }
+
+  @Test
+  public void testRemoveAclMinimalAcl() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0640));
+    fs.removeAcl(path);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] { }, returned);
+    assertPermission((short)0640);
+    assertAclFeature(false);
+  }
+
+  @Test
+  public void testRemoveAclStickyBit() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    fs.removeAcl(path);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] { }, returned);
+    assertPermission((short)01750);
+    assertAclFeature(false);
+  }
+
+  @Test
+  public void testRemoveAclOnlyDefault() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    fs.removeAcl(path);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] { }, returned);
+    assertPermission((short)0750);
+    assertAclFeature(false);
+  }
+
+  @Test(expected=FileNotFoundException.class)
+  public void testRemoveAclPathNotFound() throws IOException {
+    // Path has not been created.
+    fs.removeAcl(path);
+  }
+
+  @Test
+  public void testSetAcl() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, USER, "foo", ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, MASK, ALL),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)02770);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testSetAclOnlyAccess() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0640));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, READ_WRITE),
+      aclEntry(ACCESS, USER, "foo", READ),
+      aclEntry(ACCESS, GROUP, READ),
+      aclEntry(ACCESS, OTHER, NONE));
+    fs.setAcl(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", READ),
+      aclEntry(ACCESS, GROUP, READ) }, returned);
+    assertPermission((short)02640);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testSetAclOnlyDefault() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, USER, "foo", ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, MASK, ALL),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)02750);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testSetAclMinimal() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0644));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, READ_WRITE),
+      aclEntry(ACCESS, USER, "foo", READ),
+      aclEntry(ACCESS, GROUP, READ),
+      aclEntry(ACCESS, OTHER, NONE));
+    fs.setAcl(path, aclSpec);
+    aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, READ_WRITE),
+      aclEntry(ACCESS, GROUP, READ),
+      aclEntry(ACCESS, OTHER, NONE));
+    fs.setAcl(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] { }, returned);
+    assertPermission((short)0640);
+    assertAclFeature(false);
+  }
+
+  @Test
+  public void testSetAclMinimalDefault() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, OTHER, NONE));
+    fs.setAcl(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)02750);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testSetAclCustomMask() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0640));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, READ_WRITE),
+      aclEntry(ACCESS, USER, "foo", READ),
+      aclEntry(ACCESS, GROUP, READ),
+      aclEntry(ACCESS, MASK, ALL),
+      aclEntry(ACCESS, OTHER, NONE));
+    fs.setAcl(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", READ),
+      aclEntry(ACCESS, GROUP, READ) }, returned);
+    assertPermission((short)02670);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testSetAclStickyBit() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, USER, "foo", ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, MASK, ALL),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)03770);
+    assertAclFeature(true);
+  }
+
+  @Test(expected=FileNotFoundException.class)
+  public void testSetAclPathNotFound() throws IOException {
+    // Path has not been created.
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, READ_WRITE),
+      aclEntry(ACCESS, USER, "foo", READ),
+      aclEntry(ACCESS, GROUP, READ),
+      aclEntry(ACCESS, OTHER, NONE));
+    fs.setAcl(path, aclSpec);
+  }
+
+  @Test(expected=AclException.class)
+  public void testSetAclDefaultOnFile() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0640));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+  }
+
+  @Test
+  public void testSetPermission() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    fs.setPermission(path, FsPermission.createImmutable((short)0700));
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, USER, "foo", ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, MASK, ALL),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)02700);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testSetPermissionOnlyAccess() throws IOException {
+    fs.create(path).close();
+    fs.setPermission(path, FsPermission.createImmutable((short)0640));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, READ_WRITE),
+      aclEntry(ACCESS, USER, "foo", READ),
+      aclEntry(ACCESS, GROUP, READ),
+      aclEntry(ACCESS, OTHER, NONE));
+    fs.setAcl(path, aclSpec);
+    fs.setPermission(path, FsPermission.createImmutable((short)0600));
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(ACCESS, USER, "foo", READ),
+      aclEntry(ACCESS, GROUP, READ) }, returned);
+    assertPermission((short)02600);
+    assertAclFeature(true);
+  }
+
+  @Test
+  public void testSetPermissionOnlyDefault() throws IOException {
+    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
+    List<AclEntry> aclSpec = Lists.newArrayList(
+      aclEntry(ACCESS, USER, ALL),
+      aclEntry(ACCESS, GROUP, READ_EXECUTE),
+      aclEntry(ACCESS, OTHER, NONE),
+      aclEntry(DEFAULT, USER, "foo", ALL));
+    fs.setAcl(path, aclSpec);
+    fs.setPermission(path, FsPermission.createImmutable((short)0700));
+    AclStatus s = fs.getAclStatus(path);
+    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
+    assertArrayEquals(new AclEntry[] {
+      aclEntry(DEFAULT, USER, ALL),
+      aclEntry(DEFAULT, USER, "foo", ALL),
+      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
+      aclEntry(DEFAULT, MASK, ALL),
+      aclEntry(DEFAULT, OTHER, NONE) }, returned);
+    assertPermission((short)02700);
+    assertAclFeature(true);
+  }
+
+  /**
+   * Asserts whether or not the inode for the test path has an AclFeature.
+   *
+   * @param expectAclFeature boolean true if an AclFeature must be present,
+   *   false if an AclFeature must not be present
+   * @throws IOException thrown if there is an I/O error
+   */
+  private static void assertAclFeature(boolean expectAclFeature)
+      throws IOException {
+    INode inode = cluster.getNamesystem().getFSDirectory().getRoot()
+      .getNode(path.toUri().getPath(), false);
+    assertNotNull(inode);
+    AclFeature aclFeature = inode.getAclFeature();
+    if (expectAclFeature) {
+      assertNotNull(aclFeature);
+    } else {
+      assertNull(aclFeature);
+    }
+  }
+
+  /**
+   * Asserts the value of the FsPermission bits on the inode of the test path.
+   *
+   * @param perm short expected permission bits
+   * @throws IOException thrown if there is an I/O error
+   */
+  private static void assertPermission(short perm) throws IOException {
+    assertEquals(FsPermission.createImmutable(perm),
+      fs.getFileStatus(path).getPermission());
+  }
+}

hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/TestNameNodeAcl.java

@@ -17,803 +17,25 @@
  */
 package org.apache.hadoop.hdfs.server.namenode;
 
-import static org.apache.hadoop.hdfs.server.namenode.AclTestHelpers.*;
-import static org.apache.hadoop.fs.permission.AclEntryScope.*;
-import static org.apache.hadoop.fs.permission.AclEntryType.*;
-import static org.apache.hadoop.fs.permission.FsAction.*;
 import static org.junit.Assert.*;
 
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.util.List;
-
 import org.apache.hadoop.conf.Configuration;
-import org.apache.hadoop.fs.FileSystem;
-import org.apache.hadoop.fs.Path;
-import org.apache.hadoop.fs.permission.AclEntry;
-import org.apache.hadoop.fs.permission.AclStatus;
-import org.apache.hadoop.fs.permission.FsPermission;
+import org.apache.hadoop.hdfs.DistributedFileSystem;
 import org.apache.hadoop.hdfs.MiniDFSCluster;
-import org.apache.hadoop.hdfs.protocol.AclException;
-import org.apache.hadoop.hdfs.server.namenode.snapshot.Snapshot;
-import org.apache.hadoop.io.IOUtils;
-import org.junit.AfterClass;
-import org.junit.Before;
 import org.junit.BeforeClass;
-import org.junit.Test;
-
-import com.google.common.collect.Lists;
 
 /**
  * Tests NameNode interaction for all ACL modification APIs.  This test suite
  * also covers interaction of setPermission with inodes that have ACLs.
  */
-public class TestNameNodeAcl {
-
-  private static MiniDFSCluster cluster;
-  private static Configuration conf;
-  private static FileSystem fs;
-  private static int pathCount = 0;
-  private static Path path;
+public class TestNameNodeAcl extends FSAclBaseTest {
 
   @BeforeClass
   public static void init() throws Exception {
-    conf = new Configuration();
-
+    Configuration conf = new Configuration();
     cluster = new MiniDFSCluster.Builder(conf).numDataNodes(1).build();
     cluster.waitActive();
     fs = cluster.getFileSystem();
-  }
-
-  @AfterClass
-  public static void shutdown() throws Exception {
-    IOUtils.cleanup(null, fs);
-    if (cluster != null) {
-      cluster.shutdown();
-    }
-  }
-
-  @Before
-  public void setUp() {
-    pathCount += 1;
-    path = new Path("/p" + pathCount);
-  }
-
-  @Test
-  public void testModifyAclEntries() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE));
-    fs.modifyAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)02750);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testModifyAclEntriesOnlyAccess() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE));
-    fs.setAcl(path, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE));
-    fs.modifyAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
-    assertPermission((short)02750);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testModifyAclEntriesOnlyDefault() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE));
-    fs.modifyAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)02750);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testModifyAclEntriesMinimal() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo", READ_WRITE));
-    fs.modifyAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ_WRITE),
-      aclEntry(ACCESS, GROUP, READ) }, returned);
-    assertPermission((short)02660);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testModifyAclEntriesMinimalDefault() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE));
-    fs.modifyAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)02750);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testModifyAclEntriesCustomMask() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, MASK, NONE));
-    fs.modifyAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ) }, returned);
-    assertPermission((short)02600);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testModifyAclEntriesStickyBit() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE));
-    fs.modifyAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)03750);
-    assertAclFeature(true);
-  }
-
-  @Test(expected=FileNotFoundException.class)
-  public void testModifyAclEntriesPathNotFound() throws IOException {
-    // Path has not been created.
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE));
-    fs.modifyAclEntries(path, aclSpec);
-  }
-
-  @Test(expected=AclException.class)
-  public void testModifyAclEntriesDefaultOnFile() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.modifyAclEntries(path, aclSpec);
-  }
-
-  @Test
-  public void testRemoveAclEntries() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"),
-      aclEntry(DEFAULT, USER, "foo"));
-    fs.removeAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)02750);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testRemoveAclEntriesOnlyAccess() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, USER, "bar", READ_WRITE),
-      aclEntry(ACCESS, GROUP, READ_WRITE),
-      aclEntry(ACCESS, OTHER, NONE));
-    fs.setAcl(path, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"));
-    fs.removeAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "bar", READ_WRITE),
-      aclEntry(ACCESS, GROUP, READ_WRITE) }, returned);
-    assertPermission((short)02760);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testRemoveAclEntriesOnlyDefault() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, USER, "bar", READ_EXECUTE));
-    fs.setAcl(path, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo"));
-    fs.removeAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "bar", READ_EXECUTE),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)02750);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testRemoveAclEntriesMinimal() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0760));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_WRITE),
-      aclEntry(ACCESS, OTHER, NONE));
-    fs.setAcl(path, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"),
-      aclEntry(ACCESS, MASK));
-    fs.removeAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-    assertPermission((short)0760);
-    assertAclFeature(false);
-  }
-
-
-  @Test
-  public void testRemoveAclEntriesMinimalDefault() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"),
-      aclEntry(ACCESS, MASK),
-      aclEntry(DEFAULT, USER, "foo"),
-      aclEntry(DEFAULT, MASK));
-    fs.removeAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)02750);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testRemoveAclEntriesStickyBit() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"),
-      aclEntry(DEFAULT, USER, "foo"));
-    fs.removeAclEntries(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)03750);
-    assertAclFeature(true);
-  }
-
-  @Test(expected=FileNotFoundException.class)
-  public void testRemoveAclEntriesPathNotFound() throws IOException {
-    // Path has not been created.
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"));
-    fs.removeAclEntries(path, aclSpec);
-  }
-
-  @Test
-  public void testRemoveDefaultAcl() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    fs.removeDefaultAcl(path);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
-    assertPermission((short)02770);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testRemoveDefaultAclOnlyAccess() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE));
-    fs.setAcl(path, aclSpec);
-    fs.removeDefaultAcl(path);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
-    assertPermission((short)02770);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testRemoveDefaultAclOnlyDefault() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    fs.removeDefaultAcl(path);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-    assertPermission((short)0750);
-    assertAclFeature(false);
-  }
-
-  @Test
-  public void testRemoveDefaultAclMinimal() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    fs.removeDefaultAcl(path);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-    assertPermission((short)0750);
-    assertAclFeature(false);
-  }
-
-  @Test
-  public void testRemoveDefaultAclStickyBit() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    fs.removeDefaultAcl(path);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
-    assertPermission((short)03770);
-    assertAclFeature(true);
-  }
-
-  @Test(expected=FileNotFoundException.class)
-  public void testRemoveDefaultAclPathNotFound() throws IOException {
-    // Path has not been created.
-    fs.removeDefaultAcl(path);
-  }
-
-  @Test
-  public void testRemoveAcl() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    fs.removeAcl(path);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-    assertPermission((short)0750);
-    assertAclFeature(false);
-  }
-
-  @Test
-  public void testRemoveAclMinimalAcl() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0640));
-    fs.removeAcl(path);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-    assertPermission((short)0640);
-    assertAclFeature(false);
-  }
-
-  @Test
-  public void testRemoveAclStickyBit() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    fs.removeAcl(path);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-    assertPermission((short)01750);
-    assertAclFeature(false);
-  }
-
-  @Test
-  public void testRemoveAclOnlyDefault() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    fs.removeAcl(path);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-    assertPermission((short)0750);
-    assertAclFeature(false);
-  }
-
-  @Test(expected=FileNotFoundException.class)
-  public void testRemoveAclPathNotFound() throws IOException {
-    // Path has not been created.
-    fs.removeAcl(path);
-  }
-
-  @Test
-  public void testSetAcl() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, ALL),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)02770);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testSetAclOnlyAccess() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, OTHER, NONE));
-    fs.setAcl(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ) }, returned);
-    assertPermission((short)02640);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testSetAclOnlyDefault() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, ALL),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)02750);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testSetAclMinimal() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0644));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, OTHER, NONE));
-    fs.setAcl(path, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, OTHER, NONE));
-    fs.setAcl(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-    assertPermission((short)0640);
-    assertAclFeature(false);
-  }
-
-  @Test
-  public void testSetAclMinimalDefault() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE));
-    fs.setAcl(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)02750);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testSetAclCustomMask() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, MASK, ALL),
-      aclEntry(ACCESS, OTHER, NONE));
-    fs.setAcl(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ) }, returned);
-    assertPermission((short)02670);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testSetAclStickyBit() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)01750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, ALL),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)03770);
-    assertAclFeature(true);
-  }
-
-  @Test(expected=FileNotFoundException.class)
-  public void testSetAclPathNotFound() throws IOException {
-    // Path has not been created.
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, OTHER, NONE));
-    fs.setAcl(path, aclSpec);
-  }
-
-  @Test(expected=AclException.class)
-  public void testSetAclDefaultOnFile() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-  }
-
-  @Test
-  public void testSetPermission() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    fs.setPermission(path, FsPermission.createImmutable((short)0700));
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, ALL),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)02700);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testSetPermissionOnlyAccess() throws IOException {
-    FileSystem.create(fs, path, FsPermission.createImmutable((short)0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, OTHER, NONE));
-    fs.setAcl(path, aclSpec);
-    fs.setPermission(path, FsPermission.createImmutable((short)0600));
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ) }, returned);
-    assertPermission((short)02600);
-    assertAclFeature(true);
-  }
-
-  @Test
-  public void testSetPermissionOnlyDefault() throws IOException {
-    FileSystem.mkdirs(fs, path, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    fs.setAcl(path, aclSpec);
-    fs.setPermission(path, FsPermission.createImmutable((short)0700));
-    AclStatus s = fs.getAclStatus(path);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, ALL),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    assertPermission((short)02700);
-    assertAclFeature(true);
-  }
-
-  /**
-   * Asserts whether or not the inode for the test path has an AclFeature.
-   *
-   * @param expectAclFeature boolean true if an AclFeature must be present,
-   *   false if an AclFeature must not be present
-   * @throws IOException thrown if there is an I/O error
-   */
-  private static void assertAclFeature(boolean expectAclFeature)
-      throws IOException {
-    INode inode = cluster.getNamesystem().getFSDirectory().getRoot()
-      .getNode(path.toUri().getPath(), false);
-    assertNotNull(inode);
-    AclFeature aclFeature = inode.getAclFeature(Snapshot.CURRENT_STATE_ID);
-    if (expectAclFeature) {
-      assertNotNull(aclFeature);
-    } else {
-      assertNull(aclFeature);
-    }
-  }
-
-  /**
-   * Asserts the value of the FsPermission bits on the inode of the test path.
-   *
-   * @param perm short expected permission bits
-   * @throws IOException thrown if there is an I/O error
-   */
-  private static void assertPermission(short perm) throws IOException {
-    assertEquals(FsPermission.createImmutable(perm),
-      fs.getFileStatus(path).getPermission());
+    assertTrue(fs instanceof DistributedFileSystem);
   }
 }

hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/web/TestWebHDFS.java

@@ -18,25 +18,9 @@
 
 package org.apache.hadoop.hdfs.web;
 
-import static org.apache.hadoop.fs.permission.AclEntryScope.ACCESS;
-import static org.apache.hadoop.fs.permission.AclEntryScope.DEFAULT;
-import static org.apache.hadoop.fs.permission.AclEntryType.GROUP;
-import static org.apache.hadoop.fs.permission.AclEntryType.MASK;
-import static org.apache.hadoop.fs.permission.AclEntryType.OTHER;
-import static org.apache.hadoop.fs.permission.AclEntryType.USER;
-import static org.apache.hadoop.fs.permission.FsAction.ALL;
-import static org.apache.hadoop.fs.permission.FsAction.NONE;
-import static org.apache.hadoop.fs.permission.FsAction.READ;
-import static org.apache.hadoop.fs.permission.FsAction.READ_EXECUTE;
-import static org.apache.hadoop.fs.permission.FsAction.READ_WRITE;
-import static org.apache.hadoop.hdfs.server.namenode.AclTestHelpers.aclEntry;
-import static org.junit.Assert.assertArrayEquals;
-
-import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.net.URISyntaxException;
 import java.security.PrivilegedExceptionAction;
-import java.util.List;
 import java.util.Random;
 
 import org.apache.commons.logging.Log;
@@ -47,27 +31,18 @@ import org.apache.hadoop.fs.FSDataInputStream;
 import org.apache.hadoop.fs.FSDataOutputStream;
 import org.apache.hadoop.fs.FileSystem;
 import org.apache.hadoop.fs.Path;
-import org.apache.hadoop.fs.permission.AclEntry;
-import org.apache.hadoop.fs.permission.AclStatus;
 import org.apache.hadoop.fs.permission.FsAction;
 import org.apache.hadoop.fs.permission.FsPermission;
 import org.apache.hadoop.hdfs.DFSConfigKeys;
 import org.apache.hadoop.hdfs.HdfsConfiguration;
 import org.apache.hadoop.hdfs.MiniDFSCluster;
 import org.apache.hadoop.hdfs.TestDFSClientRetries;
-import org.apache.hadoop.hdfs.protocol.AclException;
 import org.apache.hadoop.hdfs.server.namenode.web.resources.NamenodeWebHdfsMethods;
-import org.apache.hadoop.io.IOUtils;
 import org.apache.hadoop.security.UserGroupInformation;
 import org.apache.log4j.Level;
-import org.junit.AfterClass;
 import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
 import org.junit.Test;
 
-import com.google.common.collect.Lists;
-
 /** Test WebHDFS */
 public class TestWebHDFS {
   static final Log LOG = LogFactory.getLog(TestWebHDFS.class);
@@ -76,35 +51,6 @@ public class TestWebHDFS {
   
   static final long systemStartTime = System.nanoTime();
 
-  private static MiniDFSCluster testCluster;
-  private static Configuration testConf;
-  private static FileSystem testFs;
-  private static int pathCount = 0;
-  private static Path tmpPath;
-
-  @BeforeClass
-  public static void init() throws Exception {
-    testConf = WebHdfsTestUtil.createConf();
-
-    testCluster = new MiniDFSCluster.Builder(testConf).numDataNodes(1).build();
-    testCluster.waitActive();
-    testFs = WebHdfsTestUtil.getWebHdfsFileSystem(testConf, WebHdfsFileSystem.SCHEME);
-  }
-
-  @AfterClass
-  public static void shutdown() throws Exception {
-    IOUtils.cleanup(null, testFs);
-    if (testCluster != null) {
-      testCluster.shutdown();
-    }
-  }
-
-  @Before
-  public void setUp() {
-    pathCount += 1;
-    tmpPath = new Path("/p" + pathCount);
-  }
-
   /** A timer for measuring performance. */
   static class Ticker {
     final String name;
@@ -354,648 +300,4 @@ public class TestWebHDFS {
     Assert.assertTrue(conf.getBoolean(DFSConfigKeys.DFS_WEBHDFS_ENABLED_KEY,
         false));
   }
-  
-  @Test
-  public void testModifyAclEntries() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE));
-    testFs.modifyAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-    
-    
-  }
-
-  @Test
-  public void testModifyAclEntriesOnlyAccess() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE));
-    testFs.setAcl(tmpPath, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE));
-    testFs.modifyAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
-  }
-
-  @Test
-  public void testModifyAclEntriesOnlyDefault() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE));
-    testFs.modifyAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test
-  public void testModifyAclEntriesMinimal() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo", READ_WRITE));
-    testFs.modifyAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ_WRITE),
-      aclEntry(ACCESS, GROUP, READ) }, returned);
-  }
-
-  @Test
-  public void testModifyAclEntriesMinimalDefault() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE));
-    testFs.modifyAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test
-  public void testModifyAclEntriesCustomMask() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, MASK, NONE));
-    testFs.modifyAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ) }, returned);
-  }
-
-  @Test
-  public void testModifyAclEntriesStickyBit() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)01750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE));
-    testFs.modifyAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ_EXECUTE),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", READ_EXECUTE),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test(expected=FileNotFoundException.class)
-  public void testModifyAclEntriesPathNotFound() throws IOException {
-    // Path has not been created.
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE));
-    testFs.modifyAclEntries(tmpPath, aclSpec);
-  }
-
-  @Test(expected=AclException.class)
-  public void testModifyAclEntriesDefaultOnFile() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.modifyAclEntries(tmpPath, aclSpec);
-  }
-
-  @Test
-  public void testRemoveAclEntries() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"),
-      aclEntry(DEFAULT, USER, "foo"));
-    testFs.removeAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test
-  public void testRemoveAclEntriesOnlyAccess() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, USER, "bar", READ_WRITE),
-      aclEntry(ACCESS, GROUP, READ_WRITE),
-      aclEntry(ACCESS, OTHER, NONE));
-    testFs.setAcl(tmpPath, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"));
-    testFs.removeAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "bar", READ_WRITE),
-      aclEntry(ACCESS, GROUP, READ_WRITE) }, returned);
-  }
-
-  @Test
-  public void testRemoveAclEntriesOnlyDefault() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, USER, "bar", READ_EXECUTE));
-    testFs.setAcl(tmpPath, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo"));
-    testFs.removeAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "bar", READ_EXECUTE),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test
-  public void testRemoveAclEntriesMinimal() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_WRITE),
-      aclEntry(ACCESS, OTHER, NONE));
-    testFs.setAcl(tmpPath, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"),
-      aclEntry(ACCESS, MASK));
-    System.out.println("AclSpec :"+aclSpec);
-    testFs.removeAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-  }
-
-
-  @Test
-  public void testRemoveAclEntriesMinimalDefault() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"),
-      aclEntry(ACCESS, MASK),
-      aclEntry(DEFAULT, USER, "foo"),
-      aclEntry(DEFAULT, MASK));
-    testFs.removeAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test
-  public void testRemoveAclEntriesStickyBit() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)01750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"),
-      aclEntry(DEFAULT, USER, "foo"));
-    testFs.removeAclEntries(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test(expected=FileNotFoundException.class)
-  public void testRemoveAclEntriesPathNotFound() throws IOException {
-    // Path has not been created.
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, "foo"));
-    testFs.removeAclEntries(tmpPath, aclSpec);
-  }
-
-  @Test
-  public void testRemoveDefaultAcl() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    testFs.removeDefaultAcl(tmpPath);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
-  }
-
-  @Test
-  public void testRemoveDefaultAclOnlyAccess() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE));
-    testFs.setAcl(tmpPath, aclSpec);
-    testFs.removeDefaultAcl(tmpPath);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
-  }
-
-  @Test
-  public void testRemoveDefaultAclOnlyDefault() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    testFs.removeDefaultAcl(tmpPath);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-  }
-
-  @Test
-  public void testRemoveDefaultAclMinimal() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    testFs.removeDefaultAcl(tmpPath);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-  }
-
-  @Test
-  public void testRemoveDefaultAclStickyBit() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)01750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    testFs.removeDefaultAcl(tmpPath);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE) }, returned);
-  }
-
-  @Test(expected=FileNotFoundException.class)
-  public void testRemoveDefaultAclPathNotFound() throws IOException {
-    // Path has not been created.
-    testFs.removeDefaultAcl(tmpPath);
-  }
-
-  @Test
-  public void testRemoveAcl() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    testFs.removeAcl(tmpPath);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-  }
-
-  @Test
-  public void testRemoveAclMinimalAcl() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    testFs.removeAcl(tmpPath);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-  }
-
-  @Test
-  public void testRemoveAclStickyBit() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)01750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    testFs.removeAcl(tmpPath);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-  }
-
-  @Test(expected=FileNotFoundException.class)
-  public void testRemoveAclPathNotFound() throws IOException {
-    // Path has not been created.
-    testFs.removeAcl(tmpPath);
-  }
-
-  @Test
-  public void testSetAcl() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, ALL),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test
-  public void testSetAclOnlyAccess() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, OTHER, NONE));
-    testFs.setAcl(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ) }, returned);
-  }
-
-  @Test
-  public void testSetAclOnlyDefault() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, ALL),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test
-  public void testSetAclMinimal() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, OTHER, NONE));
-    testFs.setAcl(tmpPath, aclSpec);
-    aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, OTHER, NONE));
-    testFs.setAcl(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] { }, returned);
-  }
-
-  @Test
-  public void testSetAclMinimalDefault() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE));
-    testFs.setAcl(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test
-  public void testSetAclCustomMask() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, MASK, ALL),
-      aclEntry(ACCESS, OTHER, NONE));
-    testFs.setAcl(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ) }, returned);
-  }
-
-  @Test
-  public void testSetAclStickyBit() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)01750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, ALL),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test(expected=FileNotFoundException.class)
-  public void testSetAclPathNotFound() throws IOException {
-    // Path has not been created.
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, OTHER, NONE));
-    testFs.setAcl(tmpPath, aclSpec);
-  }
-
-  @Test(expected=AclException.class)
-  public void testSetAclDefaultOnFile() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-  }
-
-  @Test
-  public void testSetPermission() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short)0700));
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, ALL),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
-
-  @Test
-  public void testSetPermissionOnlyAccess() throws IOException {
-    testFs.create(tmpPath).close();
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short) 0640));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, READ_WRITE),
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ),
-      aclEntry(ACCESS, OTHER, NONE));
-    testFs.setAcl(tmpPath, aclSpec);
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short)0600));
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(ACCESS, USER, "foo", READ),
-      aclEntry(ACCESS, GROUP, READ) }, returned);
-  }
-
-  @Test
-  public void testSetPermissionOnlyDefault() throws IOException {
-    FileSystem.mkdirs(testFs, tmpPath, FsPermission.createImmutable((short)0750));
-    List<AclEntry> aclSpec = Lists.newArrayList(
-      aclEntry(ACCESS, USER, ALL),
-      aclEntry(ACCESS, GROUP, READ_EXECUTE),
-      aclEntry(ACCESS, OTHER, NONE),
-      aclEntry(DEFAULT, USER, "foo", ALL));
-    testFs.setAcl(tmpPath, aclSpec);
-    testFs.setPermission(tmpPath, FsPermission.createImmutable((short)0700));
-    AclStatus s = testFs.getAclStatus(tmpPath);
-    AclEntry[] returned = s.getEntries().toArray(new AclEntry[0]);
-    assertArrayEquals(new AclEntry[] {
-      aclEntry(DEFAULT, USER, ALL),
-      aclEntry(DEFAULT, USER, "foo", ALL),
-      aclEntry(DEFAULT, GROUP, READ_EXECUTE),
-      aclEntry(DEFAULT, MASK, ALL),
-      aclEntry(DEFAULT, OTHER, NONE) }, returned);
-  }
 }

hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/web/TestWebHDFSAcl.java

@@ -0,0 +1,40 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hdfs.web;
+
+import static org.junit.Assert.*;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.hdfs.MiniDFSCluster;
+import org.apache.hadoop.hdfs.server.namenode.FSAclBaseTest;
+import org.junit.BeforeClass;
+
+/**
+ * Tests ACL APIs via WebHDFS.
+ */
+public class TestWebHDFSAcl extends FSAclBaseTest {
+
+  @BeforeClass
+  public static void init() throws Exception {
+    Configuration conf = WebHdfsTestUtil.createConf();
+    cluster = new MiniDFSCluster.Builder(conf).numDataNodes(1).build();
+    cluster.waitActive();
+    fs = WebHdfsTestUtil.getWebHdfsFileSystem(conf, WebHdfsFileSystem.SCHEME);
+    assertTrue(fs instanceof WebHdfsFileSystem);
+  }
+}