diff --git a/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/FSNamesystem.java b/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/FSNamesystem.java
index 79e4da4..cd3ec88 100644
--- a/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/FSNamesystem.java
+++ b/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/FSNamesystem.java
@@ -112,6 +112,7 @@
 import org.apache.hadoop.hdfs.protocol.SnapshotDiffReportListing;
 import org.apache.hadoop.hdfs.protocol.SnapshotDiffReport;
 import org.apache.hadoop.hdfs.server.common.ECTopologyVerifier;
+import org.apache.hadoop.hdfs.server.namenode.SwapBlockListOp.SwapBlockListResult;
 import org.apache.hadoop.hdfs.server.namenode.metrics.ReplicatedBlocksMBean;
 import org.apache.hadoop.hdfs.server.protocol.SlowDiskReports;
 import org.apache.hadoop.ipc.ObserverRetryOnActiveException;
@@ -8498,5 +8499,35 @@
       throw new UnsupportedActionException(operationName + " not supported.");
     }
   }
+
+  /**
+   * Namesystem API to swap block list between source and destination files.
+   *
+   * @param src source file.
+   * @param dst destination file.
+   * @throws IOException on Error.
+   */
+  boolean swapBlockList(final String src, final String dst, long genTimestamp)
+      throws IOException {
+    final String operationName = "swapBlockList";
+    checkOperation(OperationCategory.WRITE);
+    final FSPermissionChecker pc = getPermissionChecker();
+    SwapBlockListResult res = null;
+    try {
+      writeLock();
+      try {
+        checkOperation(OperationCategory.WRITE);
+        checkNameNodeSafeMode("Cannot swap block list." + src + ", " + dst);
+        res = SwapBlockListOp.swapBlocks(dir, pc, src, dst, genTimestamp);
+      } finally {
+        writeUnlock(operationName);
+      }
+    } catch (AccessControlException e) {
+      logAuditEvent(false, operationName, src, dst, null);
+      throw e;
+    }
+    logAuditEvent(true, operationName, src, dst, res.getDstFileAuditStat());
+    return res.isSuccess();
+  }
 }
 
diff --git a/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/INodeFile.java b/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/INodeFile.java
index 67c86b3..43a98d5 100644
--- a/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/INodeFile.java
+++ b/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/INodeFile.java
@@ -163,6 +163,10 @@
       return (byte)STORAGE_POLICY_ID.BITS.retrieve(header);
     }
 
+    static byte getBlockLayoutPolicy(long header) {
+      return (byte)BLOCK_LAYOUT_AND_REDUNDANCY.BITS.retrieve(header);
+    }
+
     // Union of all the block type masks. Currently there is only
     // BLOCK_TYPE_MASK_STRIPED
     static final long BLOCK_TYPE_MASK = 1 << 11;
@@ -728,6 +732,17 @@
     this.blocks = BlockInfo.EMPTY_ARRAY;
   }
 
+  /**
+   * This method replaces blocks in a file with the supplied blocks.
+   * @param newBlocks List of new blocks.
+   */
+  void replaceBlocks(BlockInfo[] newBlocks) {
+    this.blocks = Arrays.copyOf(newBlocks, newBlocks.length);
+    for (BlockInfo block : blocks) {
+      block.setBlockCollectionId(getId());
+    }
+  }
+
   private void updateRemovedUnderConstructionFiles(
       ReclaimContext reclaimContext) {
     if (isUnderConstruction() && reclaimContext.removedUCFiles != null) {
@@ -1257,4 +1272,17 @@
     return snapshotBlocks != null &&
         Arrays.asList(snapshotBlocks).contains(block);
   }
+
+  /**
+   * Update Header with new Block Layout and Redundancy bits.
+   * @param newBlockLayoutPolicy new block layout policy.
+   * @param newStoragePolicy new storage policy ID.
+   */
+  void updateHeaderWithNewPolicy(byte newBlockLayoutPolicy,
+                                 byte newStoragePolicy) {
+    this.header = HeaderFormat.toLong(
+        HeaderFormat.getPreferredBlockSize(header),
+        newBlockLayoutPolicy,
+        newStoragePolicy);
+  }
 }
diff --git a/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/NameNodeRpcServer.java b/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/NameNodeRpcServer.java
index e8dace9..7e480c5 100644
--- a/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/NameNodeRpcServer.java
+++ b/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/NameNodeRpcServer.java
@@ -2667,4 +2667,14 @@
     }
     return namesystem.getBlockManager().getSPSManager().getNextPathId();
   }
+
+  public boolean swapBlockList(String src, String dst, long maxTimestamp)
+      throws IOException {
+    checkNNStartup();
+    if (stateChangeLog.isDebugEnabled()) {
+      stateChangeLog.debug("*DIR* NameNode.swapBlockList: {} and {}", src, dst);
+    }
+    return namesystem.swapBlockList(src, dst, maxTimestamp);
+  }
+
 }
diff --git a/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/SwapBlockListOp.java b/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/SwapBlockListOp.java
new file mode 100644
index 0000000..7c02fbb
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs/src/main/java/org/apache/hadoop/hdfs/server/namenode/SwapBlockListOp.java
@@ -0,0 +1,183 @@
+/**
+ * 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 java.io.IOException;
+
+import org.apache.hadoop.fs.FileAlreadyExistsException;
+import org.apache.hadoop.fs.FileStatus;
+import org.apache.hadoop.fs.permission.FsAction;
+import org.apache.hadoop.hdfs.server.blockmanagement.BlockInfo;
+import org.apache.hadoop.hdfs.server.namenode.FSDirectory.DirOp;
+import org.apache.hadoop.hdfs.server.namenode.INodeFile.HeaderFormat;
+import org.apache.hadoop.hdfs.server.namenode.snapshot.Snapshot;
+import org.apache.hadoop.util.Time;
+
+/**
+ * Class to carry out the operation of swapping blocks from one file to another.
+ * Along with swapping blocks, we can also optionally swap the block layout
+ * of a file header, which is useful for client operations like converting
+ * replicated to EC file.
+ */
+public final class SwapBlockListOp {
+
+  private SwapBlockListOp() {
+  }
+
+  static SwapBlockListResult swapBlocks(FSDirectory fsd, FSPermissionChecker pc,
+                          String src, String dst, long genTimestamp)
+      throws IOException {
+
+    final INodesInPath srcIIP = fsd.resolvePath(pc, src, DirOp.WRITE);
+    final INodesInPath dstIIP = fsd.resolvePath(pc, dst, DirOp.WRITE);
+    if (fsd.isPermissionEnabled()) {
+      fsd.checkAncestorAccess(pc, srcIIP, FsAction.WRITE);
+      fsd.checkAncestorAccess(pc, dstIIP, FsAction.WRITE);
+    }
+    if (NameNode.stateChangeLog.isDebugEnabled()) {
+      NameNode.stateChangeLog.debug("DIR* FSDirectory.swapBlockList: "
+          + srcIIP.getPath() + " and " + dstIIP.getPath());
+    }
+    SwapBlockListResult result;
+    fsd.writeLock();
+    try {
+      result = swapBlockList(fsd, srcIIP, dstIIP, genTimestamp);
+    } finally {
+      fsd.writeUnlock();
+    }
+    return result;
+  }
+
+  private static SwapBlockListResult swapBlockList(FSDirectory fsd,
+                                    final INodesInPath srcIIP,
+                                    final INodesInPath dstIIP,
+                                    long genTimestamp)
+      throws IOException {
+
+    assert fsd.hasWriteLock();
+    validateInode(srcIIP);
+    validateInode(dstIIP);
+    fsd.ezManager.checkMoveValidity(srcIIP, dstIIP);
+
+    final String src = srcIIP.getPath();
+    final String dst = dstIIP.getPath();
+    if (dst.equals(src)) {
+      throw new FileAlreadyExistsException("The source " + src +
+          " and destination " + dst + " are the same");
+    }
+
+    INodeFile srcINodeFile = srcIIP.getLastINode().asFile();
+    INodeFile dstINodeFile = dstIIP.getLastINode().asFile();
+
+    String errorPrefix = "DIR* FSDirectory.swapBlockList: ";
+    String error = "Swap Block List destination file ";
+    BlockInfo lastBlock = dstINodeFile.getLastBlock();
+    if (lastBlock != null && lastBlock.getGenerationStamp() != genTimestamp) {
+      error  += dstIIP.getPath() +
+          " has last block with different gen timestamp.";
+      NameNode.stateChangeLog.warn(errorPrefix + error);
+      throw new IOException(error);
+    }
+
+    long mtime = Time.now();
+    BlockInfo[] dstINodeFileBlocks = dstINodeFile.getBlocks();
+    dstINodeFile.replaceBlocks(srcINodeFile.getBlocks());
+    srcINodeFile.replaceBlocks(dstINodeFileBlocks);
+
+    long srcHeader = srcINodeFile.getHeaderLong();
+    long dstHeader = dstINodeFile.getHeaderLong();
+
+    byte dstBlockLayoutPolicy =
+        HeaderFormat.getBlockLayoutPolicy(dstHeader);
+    byte srcBlockLayoutPolicy =
+        HeaderFormat.getBlockLayoutPolicy(srcHeader);
+
+    byte dstStoragePolicyID = HeaderFormat.getStoragePolicyID(dstHeader);
+    byte srcStoragePolicyID = HeaderFormat.getStoragePolicyID(srcHeader);
+
+    dstINodeFile.updateHeaderWithNewPolicy(srcBlockLayoutPolicy,
+        srcStoragePolicyID);
+    dstINodeFile.setModificationTime(mtime);
+
+    srcINodeFile.updateHeaderWithNewPolicy(dstBlockLayoutPolicy,
+        dstStoragePolicyID);
+    srcINodeFile.setModificationTime(mtime);
+
+    return new SwapBlockListResult(true,
+        fsd.getAuditFileInfo(srcIIP),
+        fsd.getAuditFileInfo(dstIIP));
+  }
+
+  private static void validateInode(INodesInPath srcIIP)
+      throws IOException {
+
+    String errorPrefix = "DIR* FSDirectory.swapBlockList: ";
+    String error = "Swap Block List input ";
+
+    INode srcInode = FSDirectory.resolveLastINode(srcIIP);
+
+    // Check if INode is a file and NOT a directory.
+    if (!srcInode.isFile()) {
+      error  += srcIIP.getPath() + " is not a file.";
+      NameNode.stateChangeLog.warn(errorPrefix + error);
+      throw new IOException(error);
+    }
+
+    // Check if file is under construction.
+    INodeFile iNodeFile = (INodeFile) srcIIP.getLastINode();
+    if (iNodeFile.isUnderConstruction()) {
+      error  += srcIIP.getPath() + " is under construction.";
+      NameNode.stateChangeLog.warn(errorPrefix + error);
+      throw new IOException(error);
+    }
+
+    // Check if any parent directory is in a snapshot.
+    if (srcIIP.getLatestSnapshotId() != Snapshot.CURRENT_STATE_ID) {
+      error  += srcIIP.getPath() + " is in a snapshot directory.";
+      NameNode.stateChangeLog.warn(errorPrefix + error);
+      throw new IOException(error);
+    }
+  }
+
+  static class SwapBlockListResult {
+    private final boolean success;
+    private final FileStatus srcFileAuditStat;
+    private final FileStatus dstFileAuditStat;
+
+    SwapBlockListResult(boolean success,
+                        FileStatus srcFileAuditStat,
+                        FileStatus dstFileAuditStat) {
+      this.success = success;
+      this.srcFileAuditStat = srcFileAuditStat;
+      this.dstFileAuditStat = dstFileAuditStat;
+    }
+
+    public boolean isSuccess() {
+      return success;
+    }
+
+    public FileStatus getDstFileAuditStat() {
+      return dstFileAuditStat;
+    }
+
+    public FileStatus getSrcFileAuditStat() {
+      return srcFileAuditStat;
+    }
+  }
+}
diff --git a/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/TestSwapBlockList.java b/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/TestSwapBlockList.java
new file mode 100644
index 0000000..d29fdee
--- /dev/null
+++ b/hadoop-hdfs-project/hadoop-hdfs/src/test/java/org/apache/hadoop/hdfs/server/namenode/TestSwapBlockList.java
@@ -0,0 +1,229 @@
+/**
+ * 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.junit.Assert.assertEquals;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.Path;
+import org.apache.hadoop.hdfs.DFSConfigKeys;
+import org.apache.hadoop.hdfs.DFSTestUtil;
+import org.apache.hadoop.hdfs.DistributedFileSystem;
+import org.apache.hadoop.hdfs.MiniDFSCluster;
+import org.apache.hadoop.hdfs.server.blockmanagement.BlockInfo;
+import org.apache.hadoop.hdfs.server.namenode.INodeFile.HeaderFormat;
+import org.apache.hadoop.hdfs.server.namenode.snapshot.SnapshotTestHelper;
+import org.apache.hadoop.test.LambdaTestUtils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Test SwapBlockListOp working.
+ */
+public class TestSwapBlockList {
+
+  private static final short REPLICATION = 3;
+
+  private static final long SEED = 0;
+  private final Path rootDir = new Path("/" + getClass().getSimpleName());
+
+  private final Path subDir1 = new Path(rootDir, "dir1");
+  private final Path file1 = new Path(subDir1, "file1");
+  private final Path file2 = new Path(subDir1, "file2");
+
+  private final Path subDir11 = new Path(subDir1, "dir11");
+  private final Path file3 = new Path(subDir11, "file3");
+
+  private final Path subDir2 = new Path(rootDir, "dir2");
+  private final Path file4 = new Path(subDir2, "file4");
+
+  private Configuration conf;
+  private MiniDFSCluster cluster;
+  private FSNamesystem fsn;
+  private FSDirectory fsdir;
+
+  private DistributedFileSystem hdfs;
+
+  @Before
+  public void setUp() throws Exception {
+    conf = new Configuration();
+    conf.setInt(DFSConfigKeys.DFS_NAMENODE_MAX_XATTRS_PER_INODE_KEY, 2);
+    cluster = new MiniDFSCluster.Builder(conf)
+        .numDataNodes(REPLICATION)
+        .build();
+    cluster.waitActive();
+
+    fsn = cluster.getNamesystem();
+    fsdir = fsn.getFSDirectory();
+
+    hdfs = cluster.getFileSystem();
+
+    hdfs.mkdirs(subDir2);
+
+    DFSTestUtil.createFile(hdfs, file1, 1024, REPLICATION, SEED);
+    DFSTestUtil.createFile(hdfs, file2, 1024, REPLICATION, SEED);
+    DFSTestUtil.createFile(hdfs, file3, 1024, REPLICATION, SEED);
+    DFSTestUtil.createFile(hdfs, file4, 1024, REPLICATION, SEED);
+
+  }
+
+  @After
+  public void tearDown() throws Exception {
+    if (cluster != null) {
+      cluster.shutdown();
+    }
+  }
+
+  @Test
+  public void testInputValidation() throws Exception {
+
+    // Source file not found.
+    LambdaTestUtils.intercept(FileNotFoundException.class,
+        "/TestSwapBlockList/dir1/fileXYZ", () -> fsn.swapBlockList(
+            "/TestSwapBlockList/dir1/fileXYZ", "/TestSwapBlockList/dir1/dir11" +
+                "/file3", 0L));
+
+    // Destination file not found.
+    LambdaTestUtils.intercept(FileNotFoundException.class,
+        "/TestSwapBlockList/dir1/dir11/fileXYZ",
+        () -> fsn.swapBlockList("/TestSwapBlockList/dir1/file1",
+            "/TestSwapBlockList/dir1/dir11/fileXYZ", 0L));
+
+    // Source is Directory, not a file.
+    LambdaTestUtils.intercept(IOException.class,
+        "/TestSwapBlockList/dir1 is not a file.",
+        () -> fsn.swapBlockList("/TestSwapBlockList/dir1",
+            "/TestSwapBlockList/dir1/dir11/file3", 0L));
+
+    String sourceFile = "/TestSwapBlockList/dir1/file1";
+    String dstFile1 = "/TestSwapBlockList/dir1/dir11/file3";
+
+    // Destination file is under construction.
+    INodeFile dstInodeFile = fsdir.resolvePath(fsdir.getPermissionChecker(),
+        dstFile1, FSDirectory.DirOp.WRITE).getLastINode().asFile();
+    dstInodeFile.toUnderConstruction("TestClient", "TestClientMachine");
+    LambdaTestUtils.intercept(IOException.class,
+        dstFile1 + " is under construction.",
+        () -> fsn.swapBlockList(sourceFile, dstFile1, 0L));
+
+    // Check if parent directory is in snapshot.
+    SnapshotTestHelper.createSnapshot(hdfs, subDir2, "s0");
+    String dstFile2 = "/TestSwapBlockList/dir2/file4";
+    LambdaTestUtils.intercept(IOException.class,
+        dstFile2 + " is in a snapshot directory",
+        () -> fsn.swapBlockList(sourceFile, dstFile2, 0L));
+
+    // Check if gen timestamp validation works.
+    String dstFile3 = "/TestSwapBlockList/dir1/file2";
+    dstInodeFile = (INodeFile) fsdir.resolvePath(fsdir.getPermissionChecker(),
+        dstFile3, FSDirectory.DirOp.WRITE).getLastINode();
+    long genStamp = dstInodeFile.getLastBlock().getGenerationStamp();
+    dstInodeFile.getLastBlock().setGenerationStamp(genStamp + 1);
+    LambdaTestUtils.intercept(IOException.class,
+        dstFile3 + " has last block with different gen timestamp.",
+        () -> fsn.swapBlockList(sourceFile, dstFile3, genStamp));
+  }
+
+  @Test
+  public void testSwapBlockListOp() throws Exception {
+    String sourceFile = "/TestSwapBlockList/dir1/file1";
+    String dstFile = "/TestSwapBlockList/dir1/dir11/file3";
+
+    INodeFile srcInodeFile =
+        (INodeFile) fsdir.resolvePath(fsdir.getPermissionChecker(),
+            sourceFile, FSDirectory.DirOp.WRITE).getLastINode();
+    INodeFile dstInodeFile =
+        (INodeFile) fsdir.resolvePath(fsdir.getPermissionChecker(),
+            dstFile, FSDirectory.DirOp.WRITE).getLastINode();
+
+    BlockInfo[] srcBlockLocationsBeforeSwap = srcInodeFile.getBlocks();
+    long srcHeader = srcInodeFile.getHeaderLong();
+
+    BlockInfo[] dstBlockLocationsBeforeSwap = dstInodeFile.getBlocks();
+    long dstHeader = dstInodeFile.getHeaderLong();
+
+    fsn.swapBlockList(sourceFile, dstFile,
+        dstInodeFile.getLastBlock().getGenerationStamp());
+    assertBlockListEquality(dstBlockLocationsBeforeSwap,
+        srcInodeFile.getBlocks(), srcInodeFile.getId());
+    assertBlockListEquality(srcBlockLocationsBeforeSwap,
+        dstInodeFile.getBlocks(), dstInodeFile.getId());
+
+    // Assert Block Layout
+    assertEquals(HeaderFormat.getBlockLayoutPolicy(srcHeader),
+        HeaderFormat.getBlockLayoutPolicy(dstInodeFile.getHeaderLong()));
+    assertEquals(HeaderFormat.getBlockLayoutPolicy(dstHeader),
+        HeaderFormat.getBlockLayoutPolicy(srcInodeFile.getHeaderLong()));
+
+    // Assert Storage policy
+    assertEquals(HeaderFormat.getStoragePolicyID(srcHeader),
+        HeaderFormat.getStoragePolicyID(dstInodeFile.getHeaderLong()));
+    assertEquals(HeaderFormat.getStoragePolicyID(dstHeader),
+        HeaderFormat.getStoragePolicyID(srcInodeFile.getHeaderLong()));
+  }
+
+  @Test
+  public void testSwapBlockListOpRollback() throws Exception {
+    // Invoke swap twice and make sure the blocks are back to their original
+    // file.
+    String sourceFile = "/TestSwapBlockList/dir1/file1";
+    String dstFile = "/TestSwapBlockList/dir1/dir11/file3";
+
+    INodeFile srcInodeFile =
+        (INodeFile) fsdir.resolvePath(fsdir.getPermissionChecker(),
+            sourceFile, FSDirectory.DirOp.WRITE).getLastINode();
+    INodeFile dstInodeFile =
+        (INodeFile) fsdir.resolvePath(fsdir.getPermissionChecker(),
+            dstFile, FSDirectory.DirOp.WRITE).getLastINode();
+
+    BlockInfo[] srcBlockLocationsBeforeSwap = srcInodeFile.getBlocks();
+    long srcHeader = srcInodeFile.getHeaderLong();
+
+    BlockInfo[] dstBlockLocationsBeforeSwap = dstInodeFile.getBlocks();
+    long dstHeader = dstInodeFile.getHeaderLong();
+
+    testSwapBlockListOp();
+    testSwapBlockListOp();
+
+    assertBlockListEquality(dstBlockLocationsBeforeSwap,
+        dstInodeFile.getBlocks(), dstInodeFile.getId());
+    assertBlockListEquality(srcBlockLocationsBeforeSwap,
+        srcInodeFile.getBlocks(), srcInodeFile.getId());
+
+    // Assert Block Layout
+    assertEquals(HeaderFormat.getBlockLayoutPolicy(srcHeader),
+        HeaderFormat.getBlockLayoutPolicy(srcInodeFile.getHeaderLong()));
+    assertEquals(HeaderFormat.getBlockLayoutPolicy(dstHeader),
+        HeaderFormat.getBlockLayoutPolicy(dstInodeFile.getHeaderLong()));
+  }
+
+  private void assertBlockListEquality(BlockInfo[] expected,
+                                       BlockInfo[] actual,
+                                       long expectedId) {
+    assertEquals(expected.length, actual.length);
+    for (int i = 0; i < expected.length; i++) {
+      assertEquals(expected[i].getBlockId(), actual[i].getBlockId());
+      assertEquals(expectedId, actual[i].getBlockCollectionId());
+    }
+  }
+}