Thank you @MichalZalecki for pointing out the removing document error. more detailed in #17

Author: SatyamSB

contracts/ERC1410/ERC1410Basic.sol

@@ -85,7 +85,7 @@ contract ERC1410Basic {
         // some tokens of the same partition as well (To avoid the array index out of bound error).
         // Note- There is no operator used for the execution of this call so `_operator` value in
         // in event is address(0) same for the `_operatorData`
-        _transferByPartition(msg.sender, _to, _value, _partition, _data, address(0), "0x0");
+        _transferByPartition(msg.sender, _to, _value, _partition, _data, address(0), "");
     }
 
     /// @notice The standard provides an on-chain function to determine whether a transfer will succeed,

contracts/ERC1410/ERC1410Standard.sol

@@ -33,7 +33,7 @@ contract ERC1410Standard is IERC1410, ERC1410Operator, Ownable {
     /// @param _data Additional data attached to the burning of tokens
     function redeemByPartition(bytes32 _partition, uint256 _value, bytes _data) external {
         // Add the function to validate the `_data` parameter
-        _redeemByPartition(_partition, msg.sender, address(0), _value, _data, "0x0");
+        _redeemByPartition(_partition, msg.sender, address(0), _value, _data, "");
     }
 
     /// @notice Decreases totalSupply and the corresponding amount of the specified partition of tokenHolder

contracts/ERC1643/ERC1643.sol

@@ -54,7 +54,7 @@ contract ERC1643 is IERC1643, Ownable {
         uint256 index = _docIndexes[_name] - 1;
         if (index != _docNames.length - 1) {
             _docNames[index] = _docNames[_docNames.length - 1];
-            _docIndexes[_name] = index + 1; 
+            _docIndexes[_docNames[index]] = index + 1; 
         }
         _docNames.length--;
         emit DocumentRemoved(_name, _documents[_name].uri, _documents[_name].docHash);

test/erc1410.js

@@ -126,9 +126,8 @@ const zero_address = "0x0000000000000000000000000000000000000000";
                 assert.equal(tx.logs[0].args._to, tokenHolder1);
                 assert.equal(web3.utils.fromWei((tx.logs[0].args._value).toString()), 5);
                 assert.equal(web3.utils.toUtf8(tx.logs[0].args._data), "");
-                assert.equal(web3.utils.toUtf8(tx.logs[0].args._operatorData), "0x0");
+                assert.equal(web3.utils.toUtf8(tx.logs[0].args._operatorData), "");
             });
-
         })
     });
 });

test/erc1643.js

@@ -19,7 +19,7 @@ const docHash = "hello";
 const empty_hash = "0x0000000000000000000000000000000000000000000000000000000000000000";
 
     async function latestTime() {
-      return (await web3.eth.getBlock("latest")).timestamp;
+        return (await web3.eth.getBlock("latest")).timestamp;
     }
 
     before(async () => {
@@ -33,113 +33,121 @@ const empty_hash = "0x0000000000000000000000000000000000000000000000000000000000
 
     describe(`Test cases for the ERC1643 contract\n`, async () => {
 
-      describe(`Test cases for the setDocument() function of the ERC1643\n`, async() => {
-
-          it("\tShould failed in executing the setDocument() function because msg.sender is not authorised\n", async() => {
-              await catchRevert(
-                  erc1643.setDocument("doc1", "https://www.gogl.bts.fly", "0x0", {from: account1})
-              );
-          });
-
-          it("\tShould failed to set a document details as name is empty\n", async() => {
-              await catchRevert(
-                erc1643.setDocument("", "https://www.gogl.bts.fly", "0x0", {from: tokenOwner})
-              );
-          });
-
-          it("\tShould failed to set a document details as URI is empty\n", async() => {
-              await catchRevert(
-                erc1643.setDocument("doc1", "", "0x0", {from: tokenOwner})
-              );
-          });
-
-          it("\tShould sucessfully add the document details in the `_documents` mapping and change the length of the `_docsNames`\n", async() => {
-              let tx = await erc1643.setDocument("doc1", uri, docHash, {from: tokenOwner});
-              assert.equal(web3.utils.toUtf8(tx.logs[0].args._name), "doc1");
-              assert.equal(tx.logs[0].args._uri, uri);
-              assert.equal(web3.utils.toUtf8(tx.logs[0].args._documentHash), docHash);
-              assert.equal((await erc1643.getAllDocuments.call()).length, 1);
-          });
-
-          it("\tShould successfully add the new document and allow the empty docHash to be added in the `Document` structure\n", async() => {
-              let tx = await erc1643.setDocument("doc2", uri, "0x0", {from: tokenOwner});
-              assert.equal(web3.utils.toUtf8(tx.logs[0].args._name), "doc2");
-              assert.equal(tx.logs[0].args._uri, uri);
-              assert.equal(tx.logs[0].args._documentHash, empty_hash);
-              assert.equal((await erc1643.getAllDocuments.call()).length, 2);
-          });
-
-          it("\tShould successfully update the existing document and length of `_docsNames` should remain unaffected\n", async() => {
-              let tx = await erc1643.setDocument("doc2", "https://www.bts.l", "0x0", {from: tokenOwner});
-              assert.equal(web3.utils.toUtf8(tx.logs[0].args._name), "doc2");
-              assert.equal(tx.logs[0].args._uri, "https://www.bts.l");
-              assert.equal(tx.logs[0].args._documentHash, empty_hash);
-              assert.equal((await erc1643.getAllDocuments.call()).length, 2);
-          });
-
-          describe("Test cases for the getters functions\n", async()=> {
-
-              it("\tShould get the details of existed document\n", async() => {
-                  let doc1Details = await erc1643.getDocument.call("doc1");
-                  assert.equal(doc1Details[0], uri);
-                  assert.equal(web3.utils.toUtf8(doc1Details[1]), docHash);
-                  assert.closeTo(doc1Details[2].toNumber(), await latestTime(), 2);
-
-                  let doc2Details = await erc1643.getDocument.call("doc2");
-                  assert.equal(doc2Details[0], "https://www.bts.l");
-                  assert.equal(doc2Details[1], empty_hash);
-                  assert.closeTo(doc2Details[2].toNumber(), await latestTime(), 2);
-              });
-
-              it("\tShould get the details of the non-existed document it means every value should be zero\n", async() => {
-                  let doc3Details = await erc1643.getDocument.call("doc3");
-                  assert.equal(doc3Details[0], "");
-                  assert.equal(web3.utils.toUtf8(doc3Details[1]), "");
-                  assert.equal(doc3Details[2], 0);
-              });
-
-              it("\tShould get all the documents present in the contract\n", async() => {
-                  let allDocs = await erc1643.getAllDocuments.call()
-                  assert.equal(allDocs.length, 2);
-                  assert.equal(web3.utils.toUtf8(allDocs[0]), "doc1");
-                  assert.equal(web3.utils.toUtf8(allDocs[1]), "doc2");
-              });
-          })
-      });
-
-      describe("Test cases for the removeDocument()\n", async() => {
-
-          it("\tShould failed to remove document because msg.sender is not authorised\n", async() => {
-              await catchRevert(
-                  erc1643.removeDocument("doc2", {from: account1})
-              );
-          });
-
-          it("\tShould failed to remove the document that is not existed in the contract\n", async() => {
-              await catchRevert(
-                  erc1643.removeDocument("doc3", {from: tokenOwner})
-              );
-          });
-
-          it("\tShould succssfully remove the document from the contract  which is present in the last index of the `_docsName` and check the params of the `DocumentRemoved` event\n", async() => {
-              // first add the new document 
-              await erc1643.setDocument("doc3", "https://www.bts.l", "0x0", {from: tokenOwner});
-              // as this will be last in the array so remove this
-              let tx = await erc1643.removeDocument("doc3", {from: tokenOwner});
-              assert.equal(web3.utils.toUtf8(tx.logs[0].args._name), "doc3");
-              assert.equal(tx.logs[0].args._uri, "https://www.bts.l");
-              assert.equal(tx.logs[0].args._documentHash, empty_hash);
-              assert.equal((await erc1643.getAllDocuments.call()).length, 2);
-
-              // remove the document that is not last in the `docsName` array
-              tx = await erc1643.removeDocument("doc1", {from: tokenOwner});
-              assert.equal(web3.utils.toUtf8(tx.logs[0].args._name), "doc1");
-              assert.equal(tx.logs[0].args._uri, uri);
-              assert.equal(web3.utils.toUtf8(tx.logs[0].args._documentHash), docHash);
-              assert.equal((await erc1643.getAllDocuments.call()).length, 1);
-          });
-
-          describe("Test cases for the getters functions\n", async()=> {
+        describe(`Test cases for the setDocument() function of the ERC1643\n`, async() => {
+
+            it("\tShould failed in executing the setDocument() function because msg.sender is not authorised\n", async() => {
+                await catchRevert(
+                    erc1643.setDocument("doc1", "https://www.gogl.bts.fly", "0x0", {from: account1})
+                );
+            });
+
+            it("\tShould failed to set a document details as name is empty\n", async() => {
+                await catchRevert(
+                    erc1643.setDocument("", "https://www.gogl.bts.fly", "0x0", {from: tokenOwner})
+                );
+            });
+
+            it("\tShould failed to set a document details as URI is empty\n", async() => {
+                await catchRevert(
+                    erc1643.setDocument("doc1", "", "0x0", {from: tokenOwner})
+                );
+            });
+
+            it("\tShould sucessfully add the document details in the `_documents` mapping and change the length of the `_docsNames`\n", async() => {
+                let tx = await erc1643.setDocument("doc1", uri, docHash, {from: tokenOwner});
+                assert.equal(web3.utils.toUtf8(tx.logs[0].args._name), "doc1");
+                assert.equal(tx.logs[0].args._uri, uri);
+                assert.equal(web3.utils.toUtf8(tx.logs[0].args._documentHash), docHash);
+                assert.equal((await erc1643.getAllDocuments.call()).length, 1);
+            });
+
+            it("\tShould successfully add the new document and allow the empty docHash to be added in the `Document` structure\n", async() => {
+                let tx = await erc1643.setDocument("doc2", uri, "0x0", {from: tokenOwner});
+                assert.equal(web3.utils.toUtf8(tx.logs[0].args._name), "doc2");
+                assert.equal(tx.logs[0].args._uri, uri);
+                assert.equal(tx.logs[0].args._documentHash, empty_hash);
+                assert.equal((await erc1643.getAllDocuments.call()).length, 2);
+            });
+
+            it("\tShould successfully update the existing document and length of `_docsNames` should remain unaffected\n", async() => {
+                let tx = await erc1643.setDocument("doc2", "https://www.bts.l", "0x0", {from: tokenOwner});
+                assert.equal(web3.utils.toUtf8(tx.logs[0].args._name), "doc2");
+                assert.equal(tx.logs[0].args._uri, "https://www.bts.l");
+                assert.equal(tx.logs[0].args._documentHash, empty_hash);
+                assert.equal((await erc1643.getAllDocuments.call()).length, 2);
+            });
+
+        describe("Test cases for the getters functions\n", async()=> {
+
+                it("\tShould get the details of existed document\n", async() => {
+                    let doc1Details = await erc1643.getDocument.call("doc1");
+                    assert.equal(doc1Details[0], uri);
+                    assert.equal(web3.utils.toUtf8(doc1Details[1]), docHash);
+                    assert.closeTo(doc1Details[2].toNumber(), await latestTime(), 2);
+
+                    let doc2Details = await erc1643.getDocument.call("doc2");
+                    assert.equal(doc2Details[0], "https://www.bts.l");
+                    assert.equal(doc2Details[1], empty_hash);
+                    assert.closeTo(doc2Details[2].toNumber(), await latestTime(), 2);
+                });
+
+                it("\tShould get the details of the non-existed document it means every value should be zero\n", async() => {
+                    let doc3Details = await erc1643.getDocument.call("doc3");
+                    assert.equal(doc3Details[0], "");
+                    assert.equal(web3.utils.toUtf8(doc3Details[1]), "");
+                    assert.equal(doc3Details[2], 0);
+                });
+
+                it("\tShould get all the documents present in the contract\n", async() => {
+                    let allDocs = await erc1643.getAllDocuments.call()
+                    assert.equal(allDocs.length, 2);
+                    assert.equal(web3.utils.toUtf8(allDocs[0]), "doc1");
+                    assert.equal(web3.utils.toUtf8(allDocs[1]), "doc2");
+                });
+            })
+        });
+
+        describe("Test cases for the removeDocument()\n", async() => {
+
+            it("\tShould failed to remove document because msg.sender is not authorised\n", async() => {
+                await catchRevert(
+                    erc1643.removeDocument("doc2", {from: account1})
+                );
+            });
+
+            it("\tShould failed to remove the document that is not existed in the contract\n", async() => {
+                await catchRevert(
+                    erc1643.removeDocument("doc3", {from: tokenOwner})
+                );
+            });
+
+            it("\tShould succssfully remove the document from the contract  which is present in the last index of the `_docsName` and check the params of the `DocumentRemoved` event\n", async() => {
+                // first add the new document 
+                await erc1643.setDocument("doc3", "https://www.bts.l", "0x0", {from: tokenOwner});
+                // as this will be last in the array so remove this
+                let tx = await erc1643.removeDocument("doc3", {from: tokenOwner});
+                assert.equal(web3.utils.toUtf8(tx.logs[0].args._name), "doc3");
+                assert.equal(tx.logs[0].args._uri, "https://www.bts.l");
+                assert.equal(tx.logs[0].args._documentHash, empty_hash);
+                assert.equal((await erc1643.getAllDocuments.call()).length, 2);
+
+                // remove the document that is not last in the `docsName` array
+                tx = await erc1643.removeDocument("doc1", {from: tokenOwner});
+                assert.equal(web3.utils.toUtf8(tx.logs[0].args._name), "doc1");
+                assert.equal(tx.logs[0].args._uri, uri);
+                assert.equal(web3.utils.toUtf8(tx.logs[0].args._documentHash), docHash);
+                assert.equal((await erc1643.getAllDocuments.call()).length, 1);
+            });
+
+            it("\t Should delete the doc to validate the #17 issue problem", async() => {
+                let tx = await erc1643.removeDocument("doc2", {from: tokenOwner});
+                assert.equal(web3.utils.toUtf8(tx.logs[0].args._name), "doc2");
+                assert.equal(tx.logs[0].args._uri, "https://www.bts.l");
+                assert.equal(web3.utils.toUtf8(tx.logs[0].args._documentHash), '');
+                assert.equal((await erc1643.getAllDocuments.call()).length, 0);
+            });
+
+        describe("Test cases for the getters functions\n", async()=> {
 
             it("\tShould get the details of the non-existed (earlier was present but get removed ) document it means every value should be zero\n", async() => {
                 let doc1Details = await erc1643.getDocument.call("doc1");
@@ -149,11 +157,13 @@ const empty_hash = "0x0000000000000000000000000000000000000000000000000000000000
             });
 
             it("\tShould get all the documents present in the contract which should be 1\n", async() => {
+                // add one doc before the getter call
+                await erc1643.setDocument("doc4", "https://www.bts.l", docHash, {from: tokenOwner})
                 let allDocs = await erc1643.getAllDocuments.call()
                 assert.equal(allDocs.length, 1);
-                assert.equal(web3.utils.toUtf8(allDocs[0]), "doc2");
+                assert.equal(web3.utils.toUtf8(allDocs[0]), "doc4");
             });
-          });
-      })
-    });
-  });
+        });
+    })
+});
+});