@Test
public void testInodeIdBasedPaths() throws Exception {

  Configuration conf = new Configuration();
  conf.setInt(DFSConfigKeys.DFS_BLOCK_SIZE_KEY,
      DFSConfigKeys.DFS_BYTES_PER_CHECKSUM_DEFAULT);
  conf.setBoolean(DFSConfigKeys.DFS_NAMENODE_ACLS_ENABLED_KEY, true);
  MiniDFSCluster cluster = null;
  try {
    cluster = new MiniDFSCluster.Builder(conf).numDataNodes(1).build();
    cluster.waitActive();
    DistributedFileSystem fs = cluster.getFileSystem();
    NamenodeProtocols nnRpc = cluster.getNameNodeRpc();
    
    // FileSystem#mkdirs "/testInodeIdBasedPaths"
    Path baseDir = getInodePath(INodeId.ROOT_INODE_ID, "testInodeIdBasedPaths");
    Path baseDirRegPath = new Path("/testInodeIdBasedPaths");
    fs.mkdirs(baseDir);
    fs.exists(baseDir);
    long baseDirFileId = nnRpc.getFileInfo(baseDir.toString()).getFileId();
    
    // FileSystem#create file and FileSystem#close
    Path testFileInodePath = getInodePath(baseDirFileId, "test1");
    Path testFileRegularPath = new Path(baseDir, "test1");
    final int testFileBlockSize = 1024;
    FileSystemTestHelper.createFile(fs, testFileInodePath, 1, testFileBlockSize);
    assertTrue(fs.exists(testFileInodePath));
    
    // FileSystem#setPermission
    FsPermission perm = new FsPermission((short)0666);
    fs.setPermission(testFileInodePath, perm);
    
    // FileSystem#getFileStatus and FileSystem#getPermission
    FileStatus fileStatus = fs.getFileStatus(testFileInodePath);
    assertEquals(perm, fileStatus.getPermission());
    
    // FileSystem#setOwner
    fs.setOwner(testFileInodePath, fileStatus.getOwner(), fileStatus.getGroup());
    
    // FileSystem#setTimes
    fs.setTimes(testFileInodePath, 0, 0);
    fileStatus = fs.getFileStatus(testFileInodePath);
    assertEquals(0, fileStatus.getModificationTime());
    assertEquals(0, fileStatus.getAccessTime());
    
    // FileSystem#setReplication
    fs.setReplication(testFileInodePath, (short)3);
    fileStatus = fs.getFileStatus(testFileInodePath);
    assertEquals(3, fileStatus.getReplication());
    fs.setReplication(testFileInodePath, (short)1);
    
    // ClientProtocol#getPreferredBlockSize
    assertEquals(testFileBlockSize,
        nnRpc.getPreferredBlockSize(testFileInodePath.toString()));
    /*
     * HDFS-6749 added missing calls to FSDirectory.resolvePath in the
     * following four methods. The calls below ensure that
     * /.reserved/.inodes paths work properly. No need to check return
     * values as these methods are tested elsewhere.
     */
    {
      fs.isFileClosed(testFileInodePath);
      fs.getAclStatus(testFileInodePath);
      fs.getXAttrs(testFileInodePath);
      fs.listXAttrs(testFileInodePath);
      fs.access(testFileInodePath, FsAction.READ_WRITE);
    }
    
    // symbolic link related tests
    
    // Reserved path is not allowed as a target
    String invalidTarget = new Path(baseDir, "invalidTarget").toString();
    String link = new Path(baseDir, "link").toString();
    testInvalidSymlinkTarget(nnRpc, invalidTarget, link);
    
    // Test creating a link using reserved inode path
    String validTarget = "/validtarget";
    testValidSymlinkTarget(nnRpc, validTarget, link);
    
    // FileSystem#append
    fs.append(testFileInodePath);
    // DistributedFileSystem#recoverLease
    
    fs.recoverLease(testFileInodePath);
    
    // Namenode#getBlockLocations
    LocatedBlocks l1 = nnRpc.getBlockLocations(testFileInodePath.toString(),
        0, Long.MAX_VALUE);
    LocatedBlocks l2 = nnRpc.getBlockLocations(testFileRegularPath.toString(),
        0, Long.MAX_VALUE);
    checkEquals(l1, l2);
    
    // FileSystem#rename - both the variants
    Path renameDst = getInodePath(baseDirFileId, "test2");
    fileStatus = fs.getFileStatus(testFileInodePath);
    // Rename variant 1: rename and rename bacck
    fs.rename(testFileInodePath, renameDst);
    fs.rename(renameDst, testFileInodePath);
    assertEquals(fileStatus, fs.getFileStatus(testFileInodePath));
    
    // Rename variant 2: rename and rename bacck
    fs.rename(testFileInodePath, renameDst, Rename.OVERWRITE);
    fs.rename(renameDst, testFileInodePath, Rename.OVERWRITE);
    assertEquals(fileStatus, fs.getFileStatus(testFileInodePath));
    
    // FileSystem#getContentSummary
    assertEquals(fs.getContentSummary(testFileRegularPath).toString(),
        fs.getContentSummary(testFileInodePath).toString());
    
    // FileSystem#listFiles
    checkEquals(fs.listFiles(baseDirRegPath, false),
        fs.listFiles(baseDir, false));
    
    // FileSystem#delete
    fs.delete(testFileInodePath, true);
    assertFalse(fs.exists(testFileInodePath));
  } finally {
    if (cluster != null) {
      cluster.shutdown();
    }
  }
}