diff --git a/tests/boost-test.hpp b/tests/boost-test.hpp
index f1b30b8..de1cfa2 100644
--- a/tests/boost-test.hpp
+++ b/tests/boost-test.hpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -24,8 +24,8 @@
 #pragma GCC system_header
 #pragma clang system_header
 
-#include <boost/test/unit_test.hpp>
 #include <boost/concept_check.hpp>
 #include <boost/test/output_test_stream.hpp>
+#include <boost/test/unit_test.hpp>
 
 #endif // NDN_GEP_TESTS_BOOST_TEST_HPP
diff --git a/tests/unit-tests/algo/aes.t.cpp b/tests/unit-tests/algo/aes.t.cpp
index 740855e..a2bf151 100644
--- a/tests/unit-tests/algo/aes.t.cpp
+++ b/tests/unit-tests/algo/aes.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -27,65 +27,64 @@
 namespace algo {
 namespace tests {
 
-const uint8_t key[] = {
-  0xdd, 0x60, 0x77, 0xec, 0xa9, 0x6b, 0x23, 0x1b,
-  0x40, 0x6b, 0x5a, 0xf8, 0x7d, 0x3d, 0x55, 0x32
-};
+const uint8_t key[] = {0xdd, 0x60, 0x77, 0xec, 0xa9, 0x6b, 0x23, 0x1b,
+                       0x40, 0x6b, 0x5a, 0xf8, 0x7d, 0x3d, 0x55, 0x32};
 
-const uint8_t plaintext[] = { // plaintext: AES-Encrypt-Test
-  0x41, 0x45, 0x53, 0x2d, 0x45, 0x6e, 0x63, 0x72,
-  0x79, 0x70, 0x74, 0x2d, 0x54, 0x65, 0x73, 0x74
-};
+// plaintext: AES-Encrypt-Test
+const uint8_t plaintext[] = { 0x41, 0x45, 0x53, 0x2d, 0x45, 0x6e, 0x63, 0x72,
+                              0x79, 0x70, 0x74, 0x2d, 0x54, 0x65, 0x73, 0x74};
 
-const uint8_t ciphertext_ecb[] = {
-  0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23,
-  0x84, 0x14, 0x15, 0x61, 0x80, 0xb9, 0x5e, 0xbd,
-  0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91, 0x31, 0xd6,
-  0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c
-};
+// const uint8_t ciphertext_ecb[] = {0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23, 0x84, 0x14, 0x15,
+//                                   0x61, 0x80, 0xb9, 0x5e, 0xbd, 0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91,
+//                                   0x31, 0xd6, 0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c};
 
-const uint8_t initvector[] = {
-  0x6f, 0x53, 0x7a, 0x65, 0x58, 0x6c, 0x65, 0x75,
-  0x44, 0x4c, 0x77, 0x35, 0x58, 0x63, 0x78, 0x6e
-};
+const uint8_t initvector[] = {0x6f, 0x53, 0x7a, 0x65, 0x58, 0x6c, 0x65, 0x75,
+                              0x44, 0x4c, 0x77, 0x35, 0x58, 0x63, 0x78, 0x6e};
 
-const uint8_t ciphertext_cbc_iv[] = {
-  0xb7, 0x19, 0x5a, 0xbb, 0x23, 0xbf, 0x92, 0xb0,
-  0x95, 0xae, 0x74, 0xe9, 0xad, 0x72, 0x7c, 0x28,
-  0x6e, 0xc6, 0x73, 0xb5, 0x0b, 0x1a, 0x9e, 0xb9,
-  0x4d, 0xc5, 0xbd, 0x8b, 0x47, 0x1f, 0x43, 0x00
-};
+const uint8_t ciphertext_cbc_iv[] = {0xb7, 0x19, 0x5a, 0xbb, 0x23, 0xbf, 0x92, 0xb0,
+                                     0x95, 0xae, 0x74, 0xe9, 0xad, 0x72, 0x7c, 0x28,
+                                     0x6e, 0xc6, 0x73, 0xb5, 0x0b, 0x1a, 0x9e, 0xb9,
+                                     0x4d, 0xc5, 0xbd, 0x8b, 0x47, 0x1f, 0x43, 0x00};
 
 BOOST_AUTO_TEST_SUITE(TestAesAlgorithm)
 
 BOOST_AUTO_TEST_CASE(EncryptionDecryption)
 {
-  RandomNumberGenerator rng;
   AesKeyParams params;
-
   EncryptParams eparams(tlv::AlgorithmAesEcb, 16);
 
   DecryptKey<Aes> decryptKey(Buffer(key, sizeof(key)));
   EncryptKey<Aes> encryptKey = Aes::deriveEncryptKey(decryptKey.getKeyBits());
 
   // check if loading key and key derivation
-  BOOST_CHECK_EQUAL_COLLECTIONS(encryptKey.getKeyBits().begin(), encryptKey.getKeyBits().end(), key, key + sizeof(key));
-  BOOST_CHECK_EQUAL_COLLECTIONS(decryptKey.getKeyBits().begin(), decryptKey.getKeyBits().end(), key, key + sizeof(key));
+  BOOST_CHECK_EQUAL_COLLECTIONS(encryptKey.getKeyBits().begin(),
+                                encryptKey.getKeyBits().end(),
+                                key, key + sizeof(key));
+  BOOST_CHECK_EQUAL_COLLECTIONS(decryptKey.getKeyBits().begin(),
+                                decryptKey.getKeyBits().end(),
+                                key, key + sizeof(key));
 
-  // encrypt data in AES_ECB
-  Buffer cipherBuf = Aes::encrypt(key, sizeof(key), plaintext, sizeof(plaintext), eparams);
-  BOOST_CHECK_EQUAL_COLLECTIONS(cipherBuf.begin(), cipherBuf.end(),
-                                ciphertext_ecb, ciphertext_ecb + sizeof(ciphertext_ecb));
+  // Comment out the test of AES_ECB because NAC no longer supports CBC.
+  // Compared with ECB, CBC is more secure.
 
-  // decrypt data in AES_ECB
-  Buffer recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.buf(), cipherBuf.size(), eparams);
-  BOOST_CHECK_EQUAL_COLLECTIONS(recvBuf.begin(), recvBuf.end(),
-                                plaintext, plaintext + sizeof(plaintext));
+  // // encrypt data in AES_ECB
+  // Buffer cipherBuf = Aes::encrypt(key, sizeof(key), plaintext, sizeof(plaintext), eparams);
+  // BOOST_CHECK_EQUAL_COLLECTIONS(cipherBuf.begin(),
+  //                               cipherBuf.end(),
+  //                               ciphertext_ecb,
+  //                               ciphertext_ecb + sizeof(ciphertext_ecb));
+
+  // // decrypt data in AES_ECB
+  // Buffer recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.data(), cipherBuf.size(), eparams);
+  // BOOST_CHECK_EQUAL_COLLECTIONS(recvBuf.begin(),
+  //                               recvBuf.end(),
+  //                               plaintext,
+  //                               plaintext + sizeof(plaintext));
 
   // encrypt/decrypt data in AES_CBC with auto-generated IV
   eparams.setAlgorithmType(tlv::AlgorithmAesCbc);
-  cipherBuf = Aes::encrypt(key, sizeof(key), plaintext, sizeof(plaintext), eparams);
-  recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.buf(), cipherBuf.size(), eparams);
+  Buffer cipherBuf = Aes::encrypt(key, sizeof(key), plaintext, sizeof(plaintext), eparams);
+  Buffer recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.data(), cipherBuf.size(), eparams);
   BOOST_CHECK_EQUAL_COLLECTIONS(recvBuf.begin(), recvBuf.end(),
                                 plaintext, plaintext + sizeof(plaintext));
 
@@ -96,7 +95,7 @@
                                 ciphertext_cbc_iv, ciphertext_cbc_iv + sizeof(ciphertext_cbc_iv));
 
   // decrypt data in AES_CBC with specified IV
-  recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.buf(), cipherBuf.size(), eparams);
+  recvBuf = Aes::decrypt(key, sizeof(key), cipherBuf.data(), cipherBuf.size(), eparams);
   BOOST_CHECK_EQUAL_COLLECTIONS(recvBuf.begin(), recvBuf.end(),
                                 plaintext, plaintext + sizeof(plaintext));
 }
diff --git a/tests/unit-tests/algo/encryptor.t.cpp b/tests/unit-tests/algo/encryptor.t.cpp
index d6c0451..59a3d5b 100644
--- a/tests/unit-tests/algo/encryptor.t.cpp
+++ b/tests/unit-tests/algo/encryptor.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -17,14 +17,13 @@
  * ndn-group-encrypt, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "random-number-generator.hpp"
-#include "encrypted-content.hpp"
 #include "algo/encryptor.hpp"
-#include "algo/rsa.hpp"
+#include "encrypted-content.hpp"
 #include "algo/aes.hpp"
+#include "algo/rsa.hpp"
 
-#include <boost/mpl/list.hpp>
 #include "boost-test.hpp"
+#include <boost/mpl/list.hpp>
 #include <algorithm>
 
 namespace ndn {
@@ -34,51 +33,6 @@
 
 BOOST_AUTO_TEST_SUITE(TestEncryptor)
 
-class TestDataAesEcb
-{
-public:
-  TestDataAesEcb()
-    : keyName("/test")
-    , encryptParams(tlv::AlgorithmAesEcb)
-  {
-    const uint8_t raw_content[] = {
-      0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
-      0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
-      0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73
-    };
-    plainText = Buffer(raw_content, sizeof(raw_content));
-
-    const uint8_t aes_key[] = {
-      0xdd, 0x60, 0x77, 0xec, 0xa9, 0x6b, 0x23, 0x1b,
-      0x40, 0x6b, 0x5a, 0xf8, 0x7d, 0x3d, 0x55, 0x32
-    };
-    key = Buffer(aes_key, sizeof(aes_key));
-
-    const uint8_t encrypted_content[] = {
-      0x15, 0x31,
-        0x82, 0x2f,
-          0x1c, 0x08,
-            0x07, 0x06,
-              0x08, 0x04, 0x74, 0x65, 0x73, 0x74,
-        0x83, 0x01,
-          0x00,
-        0x84, 0x20,
-          0x13, 0x80, 0x1a, 0xc0, 0x4c, 0x75, 0xa7, 0x7f,
-          0x43, 0x5e, 0xd7, 0xa6, 0x3f, 0xd3, 0x68, 0x94,
-          0xe2, 0xcf, 0x54, 0xb1, 0xc2, 0xce, 0xad, 0x9b,
-          0x56, 0x6e, 0x1c, 0xe6, 0x55, 0x1d, 0x79, 0x04
-    };
-    encryptedContent = Buffer(encrypted_content, sizeof(encrypted_content));
-  }
-
-public:
-  Buffer plainText;
-  Buffer key;
-  Name keyName;
-  EncryptParams encryptParams;
-  Buffer encryptedContent;
-};
-
 class TestDataAesCbc
 {
 public:
@@ -134,29 +88,39 @@
   Buffer encryptedContent;
 };
 
-typedef boost::mpl::list<TestDataAesCbc,
-                         TestDataAesEcb> EncryptorAesTestInputs;
+typedef boost::mpl::list<TestDataAesCbc> EncryptorAesTestInputs;
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(ContentSymmetricEncrypt, T, EncryptorAesTestInputs)
 {
   T input;
 
   Data data;
-  encryptData(data, input.plainText.buf(), input.plainText.size(),
-              input.keyName, input.key.buf(), input.key.size(), input.encryptParams);
+  encryptData(data,
+              input.plainText.data(),
+              input.plainText.size(),
+              input.keyName,
+              input.key.data(),
+              input.key.size(),
+              input.encryptParams);
 
   BOOST_CHECK_EQUAL(data.getName(), Name("/FOR").append(input.keyName));
 
-  BOOST_CHECK_EQUAL_COLLECTIONS(input.encryptedContent.begin(), input.encryptedContent.end(),
-                                data.getContent().wire(), data.getContent().wire() + data.getContent().size());
+  BOOST_CHECK_EQUAL_COLLECTIONS(input.encryptedContent.begin(),
+                                input.encryptedContent.end(),
+                                data.getContent().wire(),
+                                data.getContent().wire() + data.getContent().size());
 
   EncryptedContent content(data.getContent().blockFromValue());
-  const Buffer& decryptedOutput = Aes::decrypt(input.key.buf(), input.key.size(),
-                                               content.getPayload().buf(), content.getPayload().size(),
+  const Buffer& decryptedOutput = Aes::decrypt(input.key.data(),
+                                               input.key.size(),
+                                               content.getPayload().data(),
+                                               content.getPayload().size(),
                                                input.encryptParams);
 
-  BOOST_CHECK_EQUAL_COLLECTIONS(input.plainText.begin(), input.plainText.end(),
-                                decryptedOutput.begin(), decryptedOutput.end());
+  BOOST_CHECK_EQUAL_COLLECTIONS(input.plainText.begin(),
+                                input.plainText.end(),
+                                decryptedOutput.begin(),
+                                decryptedOutput.end());
 }
 
 class TestDataRsaOaep
@@ -166,6 +130,7 @@
     : type(tlv::AlgorithmRsaOaep)
   {
   }
+
 public:
   tlv::AlgorithmTypeValue type;
 };
@@ -177,30 +142,27 @@
     : type(tlv::AlgorithmRsaPkcs)
   {
   }
+
 public:
   tlv::AlgorithmTypeValue type;
 };
 
-typedef boost::mpl::list<TestDataRsaOaep,
-                         TestDataRsaPkcs> EncryptorRsaTestInputs;
+typedef boost::mpl::list<TestDataRsaOaep, TestDataRsaPkcs> EncryptorRsaTestInputs;
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(ContentAsymmetricEncryptSmall, T, EncryptorRsaTestInputs)
 {
   T type;
 
-  const uint8_t raw_content[] = {
-    0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
-    0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
-    0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73
-  };
+  const uint8_t raw_content[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
+                                 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
+                                 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x73};
 
   Data data;
-  RandomNumberGenerator rng;
   RsaKeyParams rsaParams(1024);
 
   Name keyName("test");
 
-  DecryptKey<Rsa> decryptKey = Rsa::generateKey(rng, rsaParams);
+  DecryptKey<Rsa> decryptKey = Rsa::generateKey(rsaParams);
   EncryptKey<Rsa> encryptKey = Rsa::deriveEncryptKey(decryptKey.getKeyBits());
 
   Buffer eKey = encryptKey.getKeyBits();
@@ -208,8 +170,7 @@
 
   EncryptParams encryptParams(type.type);
 
-  encryptData(data, raw_content, sizeof(raw_content),
-              keyName, eKey.buf(), eKey.size(), encryptParams);
+  encryptData(data, raw_content, sizeof(raw_content), keyName, eKey.data(), eKey.size(), encryptParams);
 
   BOOST_CHECK_EQUAL(data.getName(), Name("/FOR").append(keyName));
 
@@ -223,69 +184,53 @@
   BOOST_CHECK_EQUAL(extractContent.getAlgorithmType(), type.type);
 
   const Buffer& recovered = extractContent.getPayload();
-  Buffer decrypted = Rsa::decrypt(dKey.buf(), dKey.size(), recovered.buf(), recovered.size(), encryptParams);
-  BOOST_CHECK_EQUAL_COLLECTIONS(raw_content, raw_content + sizeof(raw_content),
-                                decrypted.begin(), decrypted.end());
+  Buffer decrypted =
+    Rsa::decrypt(dKey.data(), dKey.size(), recovered.data(), recovered.size());
+  BOOST_CHECK_EQUAL_COLLECTIONS(raw_content,
+                                raw_content + sizeof(raw_content),
+                                decrypted.begin(),
+                                decrypted.end());
 }
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(ContentAsymmetricEncryptLarge, T, EncryptorRsaTestInputs)
 {
   T type;
 
-  const uint8_t large_content[] = {
-    0x73, 0x5a, 0xbd, 0x47, 0x0c, 0xfe, 0xf8, 0x7d,
-    0x2e, 0x17, 0xaa, 0x11, 0x6f, 0x23, 0xc5, 0x10,
-    0x23, 0x36, 0x88, 0xc4, 0x2a, 0x0f, 0x9a, 0x72,
-    0x54, 0x31, 0xa8, 0xb3, 0x51, 0x18, 0x9f, 0x0e,
-    0x1b, 0x93, 0x62, 0xd9, 0xc4, 0xf5, 0xf4, 0x3d,
-    0x61, 0x9a, 0xca, 0x05, 0x65, 0x6b, 0xc6, 0x41,
-    0xf9, 0xd5, 0x1c, 0x67, 0xc1, 0xd0, 0xd5, 0x6f,
-    0x7b, 0x70, 0xb8, 0x8f, 0xdb, 0x19, 0x68, 0x7c,
-    0xe0, 0x2d, 0x04, 0x49, 0xa9, 0xa2, 0x77, 0x4e,
-    0xfc, 0x60, 0x0d, 0x7c, 0x1b, 0x93, 0x6c, 0xd2,
-    0x61, 0xc4, 0x6b, 0x01, 0xe9, 0x12, 0x28, 0x6d,
-    0xf5, 0x78, 0xe9, 0x99, 0x0b, 0x9c, 0x4f, 0x90,
-    0x34, 0x3e, 0x06, 0x92, 0x57, 0xe3, 0x7a, 0x8f,
-    0x13, 0xc7, 0xf3, 0xfe, 0xf0, 0xe2, 0x59, 0x48,
-    0x15, 0xb9, 0xdb, 0x77, 0x07, 0x1d, 0x6d, 0xb5,
-    0x65, 0x17, 0xdf, 0x76, 0x6f, 0xb5, 0x43, 0xde,
-    0x71, 0xac, 0xf1, 0x22, 0xbf, 0xb2, 0xe5, 0xd9,
-    0x22, 0xf1, 0x67, 0x76, 0x71, 0x0c, 0xff, 0x99,
-    0x7b, 0x94, 0x9b, 0x24, 0x20, 0x80, 0xe3, 0xcc,
-    0x06, 0x4a, 0xed, 0xdf, 0xec, 0x50, 0xd5, 0x87,
-    0x3d, 0xa0, 0x7d, 0x9c, 0xe5, 0x13, 0x10, 0x98,
-    0x14, 0xc3, 0x90, 0x10, 0xd9, 0x25, 0x9a, 0x59,
-    0xe9, 0x37, 0x26, 0xfd, 0x87, 0xd7, 0xf4, 0xf9,
-    0x11, 0x91, 0xad, 0x5c, 0x00, 0x95, 0xf5, 0x2b,
-    0x37, 0xf7, 0x4e, 0xb4, 0x4b, 0x42, 0x7c, 0xb3,
-    0xad, 0xd6, 0x33, 0x5f, 0x0b, 0x84, 0x57, 0x7f,
-    0xa7, 0x07, 0x73, 0x37, 0x4b, 0xab, 0x2e, 0xfb,
-    0xfe, 0x1e, 0xcb, 0xb6, 0x4a, 0xc1, 0x21, 0x5f,
-    0xec, 0x92, 0xb7, 0xac, 0x97, 0x75, 0x20, 0xc9,
-    0xd8, 0x9e, 0x93, 0xd5, 0x12, 0x7a, 0x64, 0xb9,
-    0x4c, 0xed, 0x49, 0x87, 0x44, 0x5b, 0x4f, 0x90,
-    0x34, 0x3e, 0x06, 0x92, 0x57, 0xe3, 0x7a, 0x8f,
-    0x13, 0xc7, 0xf3, 0xfe, 0xf0, 0xe2, 0x59, 0x48,
-    0x15, 0xb9, 0xdb, 0x77, 0x07, 0x1d, 0x6d, 0xb5,
-    0x65, 0x17, 0xdf, 0x76, 0x6f, 0xb5, 0x43, 0xde,
-    0x71, 0xac, 0xf1, 0x22, 0xbf, 0xb2, 0xe5, 0xd9
-  };
+  const uint8_t large_content[] =
+    {0x73, 0x5a, 0xbd, 0x47, 0x0c, 0xfe, 0xf8, 0x7d, 0x2e, 0x17, 0xaa, 0x11, 0x6f, 0x23, 0xc5,
+     0x10, 0x23, 0x36, 0x88, 0xc4, 0x2a, 0x0f, 0x9a, 0x72, 0x54, 0x31, 0xa8, 0xb3, 0x51, 0x18,
+     0x9f, 0x0e, 0x1b, 0x93, 0x62, 0xd9, 0xc4, 0xf5, 0xf4, 0x3d, 0x61, 0x9a, 0xca, 0x05, 0x65,
+     0x6b, 0xc6, 0x41, 0xf9, 0xd5, 0x1c, 0x67, 0xc1, 0xd0, 0xd5, 0x6f, 0x7b, 0x70, 0xb8, 0x8f,
+     0xdb, 0x19, 0x68, 0x7c, 0xe0, 0x2d, 0x04, 0x49, 0xa9, 0xa2, 0x77, 0x4e, 0xfc, 0x60, 0x0d,
+     0x7c, 0x1b, 0x93, 0x6c, 0xd2, 0x61, 0xc4, 0x6b, 0x01, 0xe9, 0x12, 0x28, 0x6d, 0xf5, 0x78,
+     0xe9, 0x99, 0x0b, 0x9c, 0x4f, 0x90, 0x34, 0x3e, 0x06, 0x92, 0x57, 0xe3, 0x7a, 0x8f, 0x13,
+     0xc7, 0xf3, 0xfe, 0xf0, 0xe2, 0x59, 0x48, 0x15, 0xb9, 0xdb, 0x77, 0x07, 0x1d, 0x6d, 0xb5,
+     0x65, 0x17, 0xdf, 0x76, 0x6f, 0xb5, 0x43, 0xde, 0x71, 0xac, 0xf1, 0x22, 0xbf, 0xb2, 0xe5,
+     0xd9, 0x22, 0xf1, 0x67, 0x76, 0x71, 0x0c, 0xff, 0x99, 0x7b, 0x94, 0x9b, 0x24, 0x20, 0x80,
+     0xe3, 0xcc, 0x06, 0x4a, 0xed, 0xdf, 0xec, 0x50, 0xd5, 0x87, 0x3d, 0xa0, 0x7d, 0x9c, 0xe5,
+     0x13, 0x10, 0x98, 0x14, 0xc3, 0x90, 0x10, 0xd9, 0x25, 0x9a, 0x59, 0xe9, 0x37, 0x26, 0xfd,
+     0x87, 0xd7, 0xf4, 0xf9, 0x11, 0x91, 0xad, 0x5c, 0x00, 0x95, 0xf5, 0x2b, 0x37, 0xf7, 0x4e,
+     0xb4, 0x4b, 0x42, 0x7c, 0xb3, 0xad, 0xd6, 0x33, 0x5f, 0x0b, 0x84, 0x57, 0x7f, 0xa7, 0x07,
+     0x73, 0x37, 0x4b, 0xab, 0x2e, 0xfb, 0xfe, 0x1e, 0xcb, 0xb6, 0x4a, 0xc1, 0x21, 0x5f, 0xec,
+     0x92, 0xb7, 0xac, 0x97, 0x75, 0x20, 0xc9, 0xd8, 0x9e, 0x93, 0xd5, 0x12, 0x7a, 0x64, 0xb9,
+     0x4c, 0xed, 0x49, 0x87, 0x44, 0x5b, 0x4f, 0x90, 0x34, 0x3e, 0x06, 0x92, 0x57, 0xe3, 0x7a,
+     0x8f, 0x13, 0xc7, 0xf3, 0xfe, 0xf0, 0xe2, 0x59, 0x48, 0x15, 0xb9, 0xdb, 0x77, 0x07, 0x1d,
+     0x6d, 0xb5, 0x65, 0x17, 0xdf, 0x76, 0x6f, 0xb5, 0x43, 0xde, 0x71, 0xac, 0xf1, 0x22, 0xbf,
+     0xb2, 0xe5, 0xd9};
 
   Data data;
-  RandomNumberGenerator rng;
   RsaKeyParams rsaParams(1024);
 
   Name keyName("test");
 
-  DecryptKey<Rsa> decryptKey = Rsa::generateKey(rng, rsaParams);
+  DecryptKey<Rsa> decryptKey = Rsa::generateKey(rsaParams);
   EncryptKey<Rsa> encryptKey = Rsa::deriveEncryptKey(decryptKey.getKeyBits());
 
   Buffer eKey = encryptKey.getKeyBits();
   Buffer dKey = decryptKey.getKeyBits();
 
   EncryptParams encryptParams(type.type);
-  encryptData(data, large_content, sizeof(large_content),
-              keyName, eKey.buf(), eKey.size(), encryptParams);
+  encryptData(data, large_content, sizeof(large_content), keyName, eKey.data(), eKey.size(), encryptParams);
 
   BOOST_CHECK_EQUAL(data.getName(), Name("/FOR").append(keyName));
 
@@ -317,20 +262,25 @@
   BOOST_CHECK(it == largeDataContent.elements_end());
 
   const Buffer& bufferNonce = encryptedNonce.getPayload();
-  Buffer nonce = Rsa::decrypt(dKey.buf(), dKey.size(), bufferNonce.buf(), bufferNonce.size(), encryptParams);
+  Buffer nonce =
+    Rsa::decrypt(dKey.data(), dKey.size(), bufferNonce.data(), bufferNonce.size());
 
   encryptParams.setAlgorithmType(tlv::AlgorithmAesCbc);
-  encryptParams.setIV(encryptedPayload.getInitialVector().buf(), encryptedPayload.getInitialVector().size());
+  encryptParams.setIV(encryptedPayload.getInitialVector().data(),
+                      encryptedPayload.getInitialVector().size());
   const Buffer& bufferPayload = encryptedPayload.getPayload();
-  Buffer largePayload = Aes::decrypt(nonce.buf(), nonce.size(), bufferPayload.buf(), bufferPayload.size(), encryptParams);
+  Buffer largePayload =
+    Aes::decrypt(nonce.data(), nonce.size(), bufferPayload.data(), bufferPayload.size(), encryptParams);
 
-  BOOST_CHECK_EQUAL_COLLECTIONS(large_content, large_content + sizeof(large_content),
-                                largePayload.begin(), largePayload.end());
+  BOOST_CHECK_EQUAL_COLLECTIONS(large_content,
+                                large_content + sizeof(large_content),
+                                largePayload.begin(),
+                                largePayload.end());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
 
-} // namespace algo
 } // namespace tests
+} // namespace algo
 } // namespace gep
 } // namespace ndn
diff --git a/tests/unit-tests/algo/rsa.t.cpp b/tests/unit-tests/algo/rsa.t.cpp
index d9ee899..6b7bbcb 100644
--- a/tests/unit-tests/algo/rsa.t.cpp
+++ b/tests/unit-tests/algo/rsa.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -17,109 +17,53 @@
  * ndn-group-encrypt, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <ndn-cxx/encoding/buffer-stream.hpp>
-#include "algo/encrypt-params.hpp"
 #include "algo/rsa.hpp"
-
+#include "algo/encrypt-params.hpp"
 #include "boost-test.hpp"
+#include <ndn-cxx/security/key-params.hpp>
+#include <ndn-cxx/security/transform/private-key.hpp>
+#include <ndn-cxx/security/transform/public-key.hpp>
+#include <ndn-cxx/encoding/buffer-stream.hpp>
 #include <algorithm>
 #include <string>
 
-using namespace CryptoPP;
-
 namespace ndn {
 namespace gep {
 namespace algo {
 namespace tests {
 
-const std::string privateKey = {
-  "MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAMLY2w1PmsuZNvZ4"
-  "rJs1pESLrxF1Xlk9Zg4Sc0r2HIEn/eme8f7cOxXq8OtxIjowEfjceHGvfc7YG1Nw"
-  "LDh+ka4Jh6QtYqPEL9GHfrBeufynd0g2PAPVXySBvOJr/Isk+4/Fsj5ihrIPgrQ5"
-  "wTBBuLYjDgwPppC/+vddsr5wu5bbAgMBAAECgYBYmRLB8riIa5q6aBTUXofbQ0jP"
-  "v3avTWPicjFKnK5JbE3gtQ2Evc+AH9x8smzF2KXTayy5RPsH2uxR/GefKK5EkWbB"
-  "mLwWDJ5/QPlLK1STxPs8B/89mp8sZkZ1AxnSHhV/a3dRcK1rVamVcqPMdFyM5PfX"
-  "/apL3MlL6bsq2FipAQJBAOp7EJuEs/qAjh8hgyV2acLdsokUEwXH4gCK6+KQW8XS"
-  "xFWAG4IbbLfq1HwEpHC2hJSzifCQGoPAxYBRgSK+h6sCQQDUuqF04o06+Qpe4A/W"
-  "pWCBGE33+CD4lBtaeoIagsAs/lgcFmXiJZ4+4PhyIORmwFgql9ZDFHSpl8rAYsfk"
-  "dz2RAkEAtUKpFe/BybYzJ3Galg0xuMf0ye7QvblExjKeIqiBqS1DRO0hVrSomIxZ"
-  "8f0MuWz+lI0t5t8fABa3FnjrINa0vQJBAJeZKNaTXPJZ5/oU0zS0RkG5gFbmjRiY"
-  "86VXCMC7zRhDaacajyDKjithR6yNpDdVe39fFWJYgYsakXLo8mruTwECQGqywoy9"
-  "epf1flKx4YCCrw+qRKmbkcXWcpFV32EG2K2D1GsxkuXv/b3qO67Uxx1Arxp9o8dl"
-  "k34WfzApRjNjho0="
-};
-
-const std::string publicKey = {
-  "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDC2NsNT5rLmTb2eKybNaREi68R"
-  "dV5ZPWYOEnNK9hyBJ/3pnvH+3DsV6vDrcSI6MBH43Hhxr33O2BtTcCw4fpGuCYek"
-  "LWKjxC/Rh36wXrn8p3dINjwD1V8kgbzia/yLJPuPxbI+YoayD4K0OcEwQbi2Iw4M"
-  "D6aQv/r3XbK+cLuW2wIDAQAB"
-};
-
-const uint8_t plaintext[] = { // plaintext: RSA-Encrypt-Test
-  0x52, 0x53, 0x41, 0x2d, 0x45, 0x6e, 0x63, 0x72,
-  0x79, 0x70, 0x74, 0x2d, 0x54, 0x65, 0x73, 0x74
-};
-
-const uint8_t ciphertext[] = {
-  0x33, 0xfb, 0x32, 0xd4, 0x2d, 0x45, 0x75, 0x3f, 0x34, 0xde, 0x3b,
-  0xaa, 0x80, 0x5f, 0x74, 0x6f, 0xf0, 0x3f, 0x01, 0x31, 0xdd, 0x2b,
-  0x85, 0x02, 0x1b, 0xed, 0x2d, 0x16, 0x1b, 0x96, 0xe5, 0x77, 0xde,
-  0xcd, 0x44, 0xe5, 0x3c, 0x32, 0xb6, 0x9a, 0xa9, 0x5d, 0xaa, 0x4b,
-  0x94, 0xe2, 0xac, 0x4a, 0x4e, 0xf5, 0x35, 0x21, 0xd0, 0x03, 0x4a,
-  0xa7, 0x53, 0xae, 0x13, 0x08, 0x63, 0x38, 0x2c, 0x92, 0xe3, 0x44,
-  0x64, 0xbf, 0x33, 0x84, 0x8e, 0x51, 0x9d, 0xb9, 0x85, 0x83, 0xf6,
-  0x8e, 0x09, 0xc1, 0x72, 0xb9, 0x90, 0x5d, 0x48, 0x63, 0xec, 0xd0,
-  0xcc, 0xfa, 0xab, 0x44, 0x2b, 0xaa, 0xa6, 0xb6, 0xca, 0xec, 0x2b,
-  0x5f, 0xbe, 0x77, 0xa5, 0x52, 0xeb, 0x0a, 0xaa, 0xf2, 0x2a, 0x19,
-  0x62, 0x80, 0x14, 0x87, 0x42, 0x35, 0xd0, 0xb6, 0xa3, 0x47, 0x4e,
-  0xb6, 0x1a, 0x88, 0xa3, 0x16, 0xb2, 0x19
-};
+// plaintext: RSA-Encrypt-Test
+const uint8_t plainText[] = { 0x52, 0x53, 0x41, 0x2d, 0x45, 0x6e, 0x63, 0x72,
+                              0x79, 0x70, 0x74, 0x2d, 0x54, 0x65, 0x73, 0x74};
 
 BOOST_AUTO_TEST_SUITE(TestRsaAlgorithm)
 
+BOOST_AUTO_TEST_CASE(TransformEncryptionDecryption)
+{
+  RsaKeyParams params;
+  auto sKey = security::transform::generatePrivateKey(params);
+  security::transform::PublicKey pKey;
+  ConstBufferPtr pKeyBits = sKey->derivePublicKey();
+  pKey.loadPkcs8(pKeyBits->data(), pKeyBits->size());
+
+  auto cipherText = pKey.encrypt(plainText, sizeof(plainText));
+  auto decrypted = sKey->decrypt(cipherText->data(), cipherText->size());
+  BOOST_CHECK_EQUAL_COLLECTIONS(plainText, plainText + sizeof(plainText),
+                                decrypted->begin(), decrypted->end());
+}
+
 BOOST_AUTO_TEST_CASE(EncryptionDecryption)
 {
-  RandomNumberGenerator rng;
   RsaKeyParams params;
-  EncryptParams eparams(tlv::AlgorithmRsaOaep);
+  DecryptKey<Rsa> sKey = Rsa::generateKey(params);
+  EncryptKey<Rsa> pKey = Rsa::deriveEncryptKey(sKey.getKeyBits());
 
-  OBufferStream privateKeyBuffer, publicKeyBuffer;
-  StringSource privPipe(privateKey, true,
-                        new Base64Decoder(new FileSink(privateKeyBuffer)));
-  StringSource publPipe(publicKey, true,
-                        new Base64Decoder(new FileSink(publicKeyBuffer)));
-
-  DecryptKey<Rsa> decryptKey(std::move(*(privateKeyBuffer.buf())));
-  EncryptKey<Rsa> encryptKey = Rsa::deriveEncryptKey(decryptKey.getKeyBits());
-
-  const Buffer& encodedPublicKey = *(publicKeyBuffer.buf());
-  const Buffer& derivedPublicKey = encryptKey.getKeyBits();
-  const Buffer& encodedPrivateKey = *(privateKeyBuffer.buf());
-  const Buffer& derivedPrivateKey = decryptKey.getKeyBits();
-
-  BOOST_CHECK_EQUAL_COLLECTIONS(encodedPublicKey.begin(),
-                                encodedPublicKey.end(),
-                                derivedPublicKey.begin(),
-                                derivedPublicKey.end());
-
-  const Buffer& encryptBuf = Rsa::encrypt(encodedPublicKey.buf(), encodedPublicKey.size(),
-                                          plaintext, sizeof(plaintext),
-                                          eparams);
-
-  const Buffer& recvBuf = Rsa::decrypt(encodedPrivateKey.buf(), encodedPrivateKey.size(),
-                                       encryptBuf.buf(), encryptBuf.size(),
-                                       eparams);
-
-  BOOST_CHECK_EQUAL_COLLECTIONS(plaintext, plaintext + sizeof(plaintext),
-                                recvBuf.begin(), recvBuf.end());
-
-  const Buffer& convBuf = Rsa::decrypt(derivedPrivateKey.buf(), derivedPrivateKey.size(),
-                                       ciphertext, sizeof(ciphertext),
-                                       eparams);
-
-  BOOST_CHECK_EQUAL_COLLECTIONS(plaintext, plaintext + sizeof(plaintext),
-                                convBuf.begin(), convBuf.end());
+  auto cipherText = Rsa::encrypt(pKey.getKeyBits().data(), pKey.getKeyBits().size(),
+                                 plainText, sizeof(plainText));
+  auto decrypted = Rsa::decrypt(sKey.getKeyBits().data(), sKey.getKeyBits().size(),
+                                cipherText.data(), cipherText.size());
+  BOOST_CHECK_EQUAL_COLLECTIONS(plainText, plainText + sizeof(plainText),
+                                decrypted.begin(), decrypted.end());
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/unit-tests/consumer-db.t.cpp b/tests/unit-tests/consumer-db.t.cpp
index bad6213..67c33ce 100644
--- a/tests/unit-tests/consumer-db.t.cpp
+++ b/tests/unit-tests/consumer-db.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,13 +16,13 @@
  * You should have received a copy of the GNU General Public License along with
  * ndn-group-encrypt, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  *
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
  */
 
 #include "consumer-db.hpp"
-#include "algo/rsa.hpp"
-#include "algo/aes.hpp"
 #include "boost-test.hpp"
+#include "algo/aes.hpp"
+#include "algo/rsa.hpp"
 
 #include <boost/filesystem.hpp>
 
@@ -47,9 +47,8 @@
   void
   generateRsaKey(Buffer& encryptionKeyBuf, Buffer& decryptionKeyBuf)
   {
-    RandomNumberGenerator rng;
     RsaKeyParams params;
-    DecryptKey<algo::Rsa> dKey = algo::Rsa::generateKey(rng, params);
+    DecryptKey<algo::Rsa> dKey = algo::Rsa::generateKey(params);
     decryptionKeyBuf = dKey.getKeyBits();
     EncryptKey<algo::Rsa> eKey = algo::Rsa::deriveEncryptKey(decryptionKeyBuf);
     encryptionKeyBuf = eKey.getKeyBits();
@@ -58,9 +57,8 @@
   void
   generateAesKey(Buffer& encryptionKeyBuf, Buffer& decryptionKeyBuf)
   {
-    RandomNumberGenerator rng;
     AesKeyParams params;
-    DecryptKey<algo::Aes> memberDecryptKey = algo::Aes::generateKey(rng, params);
+    DecryptKey<algo::Aes> memberDecryptKey = algo::Aes::generateKey(params);
     decryptionKeyBuf = memberDecryptKey.getKeyBits();
     EncryptKey<algo::Aes> memberEncryptKey = algo::Aes::deriveEncryptKey(decryptionKeyBuf);
     encryptionKeyBuf = memberEncryptKey.getKeyBits();
@@ -89,8 +87,7 @@
   db.addKey(keyName, dKeyBuf);
   Buffer resultBuf = db.getKey(keyName);
 
-  BOOST_CHECK_EQUAL_COLLECTIONS(dKeyBuf.begin(), dKeyBuf.end(),
-                                resultBuf.begin(), resultBuf.end());
+  BOOST_CHECK_EQUAL_COLLECTIONS(dKeyBuf.begin(), dKeyBuf.end(), resultBuf.begin(), resultBuf.end());
 
   db.deleteKey(keyName);
   resultBuf = db.getKey(keyName);
@@ -115,8 +112,7 @@
   db.addKey(keyName, dKeyBuf);
   Buffer resultBuf = db.getKey(keyName);
 
-  BOOST_CHECK_EQUAL_COLLECTIONS(dKeyBuf.begin(), dKeyBuf.end(),
-                                resultBuf.begin(), resultBuf.end());
+  BOOST_CHECK_EQUAL_COLLECTIONS(dKeyBuf.begin(), dKeyBuf.end(), resultBuf.begin(), resultBuf.end());
 
   db.deleteKey(keyName);
   resultBuf = db.getKey(keyName);
diff --git a/tests/unit-tests/consumer.t.cpp b/tests/unit-tests/consumer.t.cpp
index 15ede8b..174e247 100644
--- a/tests/unit-tests/consumer.t.cpp
+++ b/tests/unit-tests/consumer.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2016,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,41 +16,35 @@
  * You should have received a copy of the GNU General Public License along with
  * ndn-group-encrypt, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  *
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
  * @author Yingdi Yu <yingdi@cs.ucla.edu>
  */
 
 #include "consumer.hpp"
 #include "boost-test.hpp"
-#include "algo/encryptor.hpp"
 #include "unit-test-time-fixture.hpp"
+#include "algo/encryptor.hpp"
 
 #include <ndn-cxx/security/key-chain.hpp>
 #include <ndn-cxx/util/dummy-client-face.hpp>
 #include <ndn-cxx/util/time-unit-test-clock.hpp>
-#include <boost/filesystem.hpp>
 #include <boost/asio.hpp>
+#include <boost/filesystem.hpp>
 
 namespace ndn {
 namespace gep {
 namespace tests {
 
-static const uint8_t DATA_CONTEN[] = {
-  0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23,
-  0x84, 0x14, 0x15, 0x61, 0x80, 0xb9, 0x5e, 0xbd,
-  0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91, 0x31, 0xd6,
-  0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c
-};
+static const uint8_t DATA_CONTEN[] = {0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23,
+                                      0x84, 0x14, 0x15, 0x61, 0x80, 0xb9, 0x5e, 0xbd,
+                                      0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91, 0x31, 0xd6,
+                                      0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c};
 
-static const uint8_t AES_KEY[] = {
-  0xdd, 0x60, 0x77, 0xec, 0xa9, 0x6b, 0x23, 0x1b,
-  0x40, 0x6b, 0x5a, 0xf8, 0x7d, 0x3d, 0x55, 0x32
-};
+static const uint8_t AES_KEY[] =
+  {0xdd, 0x60, 0x77, 0xec, 0xa9, 0x6b, 0x23, 0x1b, 0x40, 0x6b, 0x5a, 0xf8, 0x7d, 0x3d, 0x55, 0x32};
 
-static const uint8_t IV[] = {
-  0x73, 0x6f, 0x6d, 0x65, 0x72, 0x61, 0x6e, 0x64,
-  0x6f, 0x6d, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72
-};
+static const uint8_t IV[] =
+  {0x73, 0x6f, 0x6d, 0x65, 0x72, 0x61, 0x6e, 0x64, 0x6f, 0x6d, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72};
 
 class ConsumerFixture : public UnitTestTimeFixture
 {
@@ -74,13 +68,12 @@
     boost::filesystem::create_directories(tmpPath);
 
     // generate e/d key
-    RandomNumberGenerator rng;
     RsaKeyParams params;
-    fixtureDKeyBuf = algo::Rsa::generateKey(rng, params).getKeyBits();
+    fixtureDKeyBuf = algo::Rsa::generateKey(params).getKeyBits();
     fixtureEKeyBuf = algo::Rsa::deriveEncryptKey(fixtureDKeyBuf).getKeyBits();
 
     // generate user key
-    fixtureUDKeyBuf = algo::Rsa::generateKey(rng, params).getKeyBits();
+    fixtureUDKeyBuf = algo::Rsa::generateKey(params).getKeyBits();
     fixtureUEKeyBuf = algo::Rsa::deriveEncryptKey(fixtureUDKeyBuf).getKeyBits();
 
     // load C-KEY
@@ -98,8 +91,13 @@
     shared_ptr<Data> contentData = make_shared<Data>(contentName);
     algo::EncryptParams eparams(tlv::AlgorithmAesCbc);
     eparams.setIV(IV, sizeof(IV));
-    algo::encryptData(*contentData, DATA_CONTEN, sizeof(DATA_CONTEN), cKeyName,
-                      fixtureCKeyBuf.buf(), fixtureCKeyBuf.size(), eparams);
+    algo::encryptData(*contentData,
+                      DATA_CONTEN,
+                      sizeof(DATA_CONTEN),
+                      cKeyName,
+                      fixtureCKeyBuf.data(),
+                      fixtureCKeyBuf.size(),
+                      eparams);
     keyChain.sign(*contentData);
     return contentData;
   }
@@ -109,8 +107,13 @@
   {
     shared_ptr<Data> cKeyData = make_shared<Data>(cKeyName);
     algo::EncryptParams eparams(tlv::AlgorithmRsaOaep);
-    algo::encryptData(*cKeyData, fixtureCKeyBuf.buf(), fixtureCKeyBuf.size(), dKeyName,
-                      fixtureEKeyBuf.buf(), fixtureEKeyBuf.size(), eparams);
+    algo::encryptData(*cKeyData,
+                      fixtureCKeyBuf.data(),
+                      fixtureCKeyBuf.size(),
+                      dKeyName,
+                      fixtureEKeyBuf.data(),
+                      fixtureEKeyBuf.size(),
+                      eparams);
     keyChain.sign(*cKeyData);
     return cKeyData;
   }
@@ -120,8 +123,13 @@
   {
     shared_ptr<Data> dKeyData = make_shared<Data>(dKeyName);
     algo::EncryptParams eparams(tlv::AlgorithmRsaOaep);
-    algo::encryptData(*dKeyData, fixtureDKeyBuf.buf(), fixtureDKeyBuf.size(), uKeyName,
-                      fixtureUEKeyBuf.buf(), fixtureUEKeyBuf.size(), eparams);
+    algo::encryptData(*dKeyData,
+                      fixtureDKeyBuf.data(),
+                      fixtureDKeyBuf.size(),
+                      uKeyName,
+                      fixtureUEKeyBuf.data(),
+                      fixtureUEKeyBuf.size(),
+                      eparams);
     keyChain.sign(*dKeyData);
     return dKeyData;
   }
@@ -202,26 +210,24 @@
   // decrypt
   consumer.decrypt(cKeyData->getContent().blockFromValue(),
                    fixtureDKeyBuf,
-                   [=](const Buffer& result){
-                     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
+                   [=] (const Buffer& result) {
+                     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(),
+                                                   result.end(),
                                                    aesKeyBuf.begin(),
                                                    aesKeyBuf.end());
                    },
-                   [=](const ErrorCode&, const std::string&){
-                     BOOST_CHECK(false);
-                   });
+                   [=] (const ErrorCode&, const std::string&) { BOOST_CHECK(false); });
 
   // decrypt
   consumer.decrypt(contentData->getContent().blockFromValue(),
                    fixtureCKeyBuf,
-                   [=](const Buffer& result){
-                     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
+                   [=] (const Buffer& result) {
+                     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(),
+                                                   result.end(),
                                                    DATA_CONTEN,
                                                    DATA_CONTEN + sizeof(DATA_CONTEN));
                    },
-                   [=](const ErrorCode&, const std::string&){
-                     BOOST_CHECK(false);
-                   });
+                   [=] (const ErrorCode&, const std::string&) { BOOST_CHECK(false); });
 }
 
 BOOST_AUTO_TEST_CASE(Consume)
@@ -256,7 +262,7 @@
                             return;
                           },
                           RegisterPrefixSuccessCallback(),
-                          [] (const Name&, const std::string& e) { });
+                          [] (const Name&, const std::string& e) {});
 
   do {
     advanceClocks(time::milliseconds(10), 20);
@@ -270,15 +276,14 @@
 
   int finalCount = 0;
   consumer.consume(contentName,
-                   [&](const Data& data, const Buffer& result){
+                   [&] (const Data& data, const Buffer& result) {
                      finalCount = 1;
-                     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(),
+                     BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(),
+                                                   result.end(),
                                                    DATA_CONTEN,
                                                    DATA_CONTEN + sizeof(DATA_CONTEN));
                    },
-                   [&](const ErrorCode& code, const std::string& str){
-                     BOOST_CHECK(false);
-                   });
+                   [&] (const ErrorCode& code, const std::string& str) { BOOST_CHECK(false); });
 
   do {
     advanceClocks(time::milliseconds(10), 20);
@@ -305,7 +310,7 @@
   // prepare face1
   face1.setInterestFilter(prefix,
                           [&] (const InterestFilter&, const Interest& i) {
-                            BOOST_CHECK(i.getLink().getDelegations().size() == 3);
+                            BOOST_CHECK(i.getForwardingHint().size() == 3);
                             if (i.matchesData(*contentData)) {
                               contentCount++;
                               face1.put(*contentData);
@@ -324,7 +329,7 @@
                             return;
                           },
                           RegisterPrefixSuccessCallback(),
-                          [] (const Name&, const std::string& e) { });
+                          [] (const Name&, const std::string& e) {});
 
   do {
     advanceClocks(time::milliseconds(10), 20);
@@ -345,13 +350,11 @@
   consumer.addDecryptionKey(uKeyName, fixtureUDKeyBuf);
 
   consumer.consume(contentName,
-                   [&](const Data& data, const Buffer& result){
+                   [&] (const Data& data, const Buffer& result) {
                      BOOST_CHECK(true);
                      resultCount++;
                    },
-                   [](const ErrorCode& code, const std::string& str){
-                     BOOST_CHECK(false);
-                   },
+                   [] (const ErrorCode& code, const std::string& str) { BOOST_CHECK(false); },
                    datalink);
 
   do {
@@ -366,6 +369,6 @@
 
 BOOST_AUTO_TEST_SUITE_END()
 
-} // namespace test
+} // namespace tests
 } // namespace gep
 } // namespace ndn
diff --git a/tests/unit-tests/encrypted-content.t.cpp b/tests/unit-tests/encrypted-content.t.cpp
index f6877fc..413fad9 100644
--- a/tests/unit-tests/encrypted-content.t.cpp
+++ b/tests/unit-tests/encrypted-content.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
diff --git a/tests/unit-tests/group-manager-db.t.cpp b/tests/unit-tests/group-manager-db.t.cpp
index 16a2c81..0800af3 100644
--- a/tests/unit-tests/group-manager-db.t.cpp
+++ b/tests/unit-tests/group-manager-db.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,13 +16,12 @@
  * You should have received a copy of the GNU General Public License along with
  * ndn-group-encrypt, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  *
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
  */
 
 #include "group-manager-db.hpp"
-#include "algo/rsa.hpp"
 #include "boost-test.hpp"
-
+#include "algo/rsa.hpp"
 #include <boost/filesystem.hpp>
 
 namespace ndn {
@@ -136,9 +135,8 @@
   Schedule schedule(scheduleBlock);
 
   // create member
-  RandomNumberGenerator rng;
   RsaKeyParams params;
-  DecryptKey<algo::Rsa> decryptKey = algo::Rsa::generateKey(rng, params);
+  DecryptKey<algo::Rsa> decryptKey = algo::Rsa::generateKey(params);
   EncryptKey<algo::Rsa> encryptKey = algo::Rsa::deriveEncryptKey(decryptKey.getKeyBits());
   Buffer keyBuf = encryptKey.getKeyBits();
 
diff --git a/tests/unit-tests/group-manager.t.cpp b/tests/unit-tests/group-manager.t.cpp
index dc64eda..5994d66 100644
--- a/tests/unit-tests/group-manager.t.cpp
+++ b/tests/unit-tests/group-manager.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,17 +16,16 @@
  * You should have received a copy of the GNU General Public License along with
  * ndn-group-encrypt, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  *
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
  */
 
 #include "group-manager.hpp"
 #include "boost-test.hpp"
-#include "algo/rsa.hpp"
-#include "algo/aes.hpp"
 #include "encrypted-content.hpp"
-
-#include <boost/filesystem.hpp>
+#include "algo/aes.hpp"
+#include "algo/rsa.hpp"
 #include <ndn-cxx/encoding/buffer-stream.hpp>
+#include <boost/filesystem.hpp>
 #include <string>
 
 namespace ndn {
@@ -35,33 +34,25 @@
 
 using namespace boost::posix_time;
 
-const uint8_t SIG_INFO[] = {
-  0x16, 0x1b, // SignatureInfo
-      0x1b, 0x01, // SignatureType
-          0x01,
-      0x1c, 0x16, // KeyLocator
-          0x07, 0x14, // Name
-              0x08, 0x04,
-                  0x74, 0x65, 0x73, 0x74,
-              0x08, 0x03,
-                  0x6b, 0x65, 0x79,
-              0x08, 0x07,
-                  0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72
-};
+const uint8_t SIG_INFO[] = {0x16, 0x1b,       // SignatureInfo
+                            0x1b, 0x01,       // SignatureType
+                            0x01, 0x1c, 0x16, // KeyLocator
+                            0x07, 0x14,       // Name
+                            0x08, 0x04, 0x74, 0x65, 0x73, 0x74, 0x08, 0x03, 0x6b, 0x65,
+                            0x79, 0x08, 0x07, 0x6c, 0x6f, 0x63, 0x61, 0x74, 0x6f, 0x72};
 
-const uint8_t SIG_VALUE[] = {
-  0x17, 0x80, // SignatureValue
-      0x2f, 0xd6, 0xf1, 0x6e, 0x80, 0x6f, 0x10, 0xbe, 0xb1, 0x6f, 0x3e, 0x31, 0xec,
-      0xe3, 0xb9, 0xea, 0x83, 0x30, 0x40, 0x03, 0xfc, 0xa0, 0x13, 0xd9, 0xb3, 0xc6,
-      0x25, 0x16, 0x2d, 0xa6, 0x58, 0x41, 0x69, 0x62, 0x56, 0xd8, 0xb3, 0x6a, 0x38,
-      0x76, 0x56, 0xea, 0x61, 0xb2, 0x32, 0x70, 0x1c, 0xb6, 0x4d, 0x10, 0x1d, 0xdc,
-      0x92, 0x8e, 0x52, 0xa5, 0x8a, 0x1d, 0xd9, 0x96, 0x5e, 0xc0, 0x62, 0x0b, 0xcf,
-      0x3a, 0x9d, 0x7f, 0xca, 0xbe, 0xa1, 0x41, 0x71, 0x85, 0x7a, 0x8b, 0x5d, 0xa9,
-      0x64, 0xd6, 0x66, 0xb4, 0xe9, 0x8d, 0x0c, 0x28, 0x43, 0xee, 0xa6, 0x64, 0xe8,
-      0x55, 0xf6, 0x1c, 0x19, 0x0b, 0xef, 0x99, 0x25, 0x1e, 0xdc, 0x78, 0xb3, 0xa7,
-      0xaa, 0x0d, 0x14, 0x58, 0x30, 0xe5, 0x37, 0x6a, 0x6d, 0xdb, 0x56, 0xac, 0xa3,
-      0xfc, 0x90, 0x7a, 0xb8, 0x66, 0x9c, 0x0e, 0xf6, 0xb7, 0x64, 0xd1
-};
+const uint8_t SIG_VALUE[] = {0x17, 0x80, // SignatureValue
+                             0x2f, 0xd6, 0xf1, 0x6e, 0x80, 0x6f, 0x10, 0xbe, 0xb1, 0x6f, 0x3e, 0x31,
+                             0xec, 0xe3, 0xb9, 0xea, 0x83, 0x30, 0x40, 0x03, 0xfc, 0xa0, 0x13, 0xd9,
+                             0xb3, 0xc6, 0x25, 0x16, 0x2d, 0xa6, 0x58, 0x41, 0x69, 0x62, 0x56, 0xd8,
+                             0xb3, 0x6a, 0x38, 0x76, 0x56, 0xea, 0x61, 0xb2, 0x32, 0x70, 0x1c, 0xb6,
+                             0x4d, 0x10, 0x1d, 0xdc, 0x92, 0x8e, 0x52, 0xa5, 0x8a, 0x1d, 0xd9, 0x96,
+                             0x5e, 0xc0, 0x62, 0x0b, 0xcf, 0x3a, 0x9d, 0x7f, 0xca, 0xbe, 0xa1, 0x41,
+                             0x71, 0x85, 0x7a, 0x8b, 0x5d, 0xa9, 0x64, 0xd6, 0x66, 0xb4, 0xe9, 0x8d,
+                             0x0c, 0x28, 0x43, 0xee, 0xa6, 0x64, 0xe8, 0x55, 0xf6, 0x1c, 0x19, 0x0b,
+                             0xef, 0x99, 0x25, 0x1e, 0xdc, 0x78, 0xb3, 0xa7, 0xaa, 0x0d, 0x14, 0x58,
+                             0x30, 0xe5, 0x37, 0x6a, 0x6d, 0xdb, 0x56, 0xac, 0xa3, 0xfc, 0x90, 0x7a,
+                             0xb8, 0x66, 0x9c, 0x0e, 0xf6, 0xb7, 0x64, 0xd1};
 
 class GroupManagerFixture
 {
@@ -72,18 +63,15 @@
     boost::filesystem::create_directories(tmpPath);
 
     // generate the certificate public key
-    RandomNumberGenerator rng;
     RsaKeyParams params;
-    DecryptKey<algo::Rsa> memberDecryptKey = algo::Rsa::generateKey(rng, params);
+    DecryptKey<algo::Rsa> memberDecryptKey = algo::Rsa::generateKey(params);
     decryptKeyBuf = memberDecryptKey.getKeyBits();
     EncryptKey<algo::Rsa> memberEncryptKey = algo::Rsa::deriveEncryptKey(decryptKeyBuf);
     encryptKeyBuf = memberEncryptKey.getKeyBits();
 
     // generate certificate
     cert.setName(Name("/ndn/memberA/KEY/ksk-123/ID-CERT/123"));
-    PublicKey contentPubKey(encryptKeyBuf.buf(), encryptKeyBuf.size());
-    cert.setPublicKeyInfo(contentPubKey);
-    cert.encode();
+    cert.setContent(encryptKeyBuf.data(), encryptKeyBuf.size());
 
     Block sigInfoBlock(SIG_INFO, sizeof(SIG_INFO));
     Block sigValueBlock(SIG_VALUE, sizeof(SIG_VALUE));
@@ -101,13 +89,20 @@
     Schedule schedule1;
     RepetitiveInterval interval11(from_iso_string("20150825T000000"),
                                   from_iso_string("20150827T000000"),
-                                  5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+                                  5,
+                                  10,
+                                  2,
+                                  RepetitiveInterval::RepeatUnit::DAY);
     RepetitiveInterval interval12(from_iso_string("20150825T000000"),
                                   from_iso_string("20150827T000000"),
-                                  6, 8, 1, RepetitiveInterval::RepeatUnit::DAY);
+                                  6,
+                                  8,
+                                  1,
+                                  RepetitiveInterval::RepeatUnit::DAY);
     RepetitiveInterval interval13(from_iso_string("20150827T000000"),
                                   from_iso_string("20150827T000000"),
-                                  7, 8);
+                                  7,
+                                  8);
     schedule1.addWhiteInterval(interval11);
     schedule1.addWhiteInterval(interval12);
     schedule1.addBlackInterval(interval13);
@@ -116,13 +111,18 @@
     Schedule schedule2;
     RepetitiveInterval interval21(from_iso_string("20150825T000000"),
                                   from_iso_string("20150827T000000"),
-                                  9, 12, 1, RepetitiveInterval::RepeatUnit::DAY);
+                                  9,
+                                  12,
+                                  1,
+                                  RepetitiveInterval::RepeatUnit::DAY);
     RepetitiveInterval interval22(from_iso_string("20150827T000000"),
                                   from_iso_string("20150827T000000"),
-                                  6, 8);
+                                  6,
+                                  8);
     RepetitiveInterval interval23(from_iso_string("20150827T000000"),
                                   from_iso_string("20150827T000000"),
-                                  2, 4);
+                                  2,
+                                  4);
     schedule2.addWhiteInterval(interval21);
     schedule2.addWhiteInterval(interval22);
     schedule2.addBlackInterval(interval23);
@@ -156,7 +156,7 @@
   boost::filesystem::path tmpPath;
   Buffer decryptKeyBuf;
   Buffer encryptKeyBuf;
-  IdentityCertificate cert;
+  Certificate cert;
 };
 
 BOOST_FIXTURE_TEST_SUITE(TestGroupManager, GroupManagerFixture)
@@ -169,11 +169,15 @@
   GroupManager manager(Name("Alice"), Name("data_type"), dbDir, 2048, 1);
 
   Block newCertBlock = cert.wireEncode();
-  IdentityCertificate newCert(newCertBlock);
+  Certificate newCert(newCertBlock);
 
   // encrypt D-KEY
-  Data data = manager.createDKeyData("20150825T000000", "20150827T000000", Name("/ndn/memberA/KEY"),
-                                     decryptKeyBuf, newCert.getPublicKeyInfo().get());
+  Data data = manager.createDKeyData("20150825T000000",
+                                     "20150827T000000",
+                                     Name("/ndn/memberA/KEY"),
+                                     decryptKeyBuf,
+                                     Buffer(newCert.getContent().value(),
+                                            newCert.getContent().value_size()));
 
   // verify encrypted D-KEY
   Block dataContent = data.getContent();
@@ -189,9 +193,10 @@
   BOOST_CHECK_EQUAL(encryptedNonce.getAlgorithmType(), tlv::AlgorithmRsaOaep);
 
   const Buffer& bufferNonce = encryptedNonce.getPayload();
-  algo::EncryptParams decryptParams(tlv::AlgorithmRsaOaep);
-  Buffer nonce = algo::Rsa::decrypt(decryptKeyBuf.buf(), decryptKeyBuf.size(),
-                                    bufferNonce.buf(), bufferNonce.size(), decryptParams);
+  Buffer nonce = algo::Rsa::decrypt(decryptKeyBuf.data(),
+                                    decryptKeyBuf.size(),
+                                    bufferNonce.data(),
+                                    bufferNonce.size());
 
   // get D-KEY
   contentIterator++;
@@ -201,16 +206,20 @@
   BOOST_CHECK_EQUAL(encryptedPayload.getInitialVector().size(), 16);
   BOOST_CHECK_EQUAL(encryptedPayload.getAlgorithmType(), tlv::AlgorithmAesCbc);
 
-  decryptParams.setAlgorithmType(tlv::AlgorithmAesCbc);
-  decryptParams.setIV(encryptedPayload.getInitialVector().buf(),
+  algo::EncryptParams decryptParams(tlv::AlgorithmAesCbc);
+  decryptParams.setIV(encryptedPayload.getInitialVector().data(),
                       encryptedPayload.getInitialVector().size());
   const Buffer& bufferPayload = encryptedPayload.getPayload();
-  Buffer largePayload = algo::Aes::decrypt(nonce.buf(), nonce.size(),
-                                           bufferPayload.buf(), bufferPayload.size(),
+  Buffer largePayload = algo::Aes::decrypt(nonce.data(),
+                                           nonce.size(),
+                                           bufferPayload.data(),
+                                           bufferPayload.size(),
                                            decryptParams);
 
-  BOOST_CHECK_EQUAL_COLLECTIONS(largePayload.begin(), largePayload.end(),
-                                decryptKeyBuf.begin(), decryptKeyBuf.end());
+  BOOST_CHECK_EQUAL_COLLECTIONS(largePayload.begin(),
+                                largePayload.end(),
+                                decryptKeyBuf.begin(),
+                                decryptKeyBuf.end());
 }
 
 BOOST_AUTO_TEST_CASE(CreateEKeyData)
@@ -228,9 +237,10 @@
                     "/Alice/READ/data_type/E-KEY/20150825T090000/20150825T110000");
 
   Buffer contentBuf(data.getContent().value(), data.getContent().value_size());
-  BOOST_CHECK_EQUAL_COLLECTIONS(encryptKeyBuf.begin(), encryptKeyBuf.end(),
-                                contentBuf.begin(), contentBuf.end());
-
+  BOOST_CHECK_EQUAL_COLLECTIONS(encryptKeyBuf.begin(),
+                                encryptKeyBuf.end(),
+                                contentBuf.begin(),
+                                contentBuf.end());
 }
 
 BOOST_AUTO_TEST_CASE(CalculateInterval)
@@ -286,13 +296,14 @@
   std::list<Data>::iterator dataIterator = result.begin();
   BOOST_CHECK_EQUAL(dataIterator->getName().toUri(),
                     "/Alice/READ/data_type/E-KEY/20150825T090000/20150825T100000");
-  EncryptKey<algo::Rsa> groupEKey(Buffer(dataIterator->getContent().value(),
-                                         dataIterator->getContent().value_size()));
+
+  EncryptKey<algo::Rsa> groupEKey(
+    Buffer(dataIterator->getContent().value(), dataIterator->getContent().value_size()));
 
   // second data and decrypt
   dataIterator++;
   BOOST_CHECK_EQUAL(dataIterator->getName().toUri(),
-                    "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/ksk-123");
+                    "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/KEY/ksk-123");
 
   //////////////////////////////////////////////////////////////////////// start decryption
   Block dataContent = dataIterator->getContent();
@@ -308,11 +319,12 @@
   BOOST_CHECK_EQUAL(encryptedNonce.getInitialVector().size(), 0);
   BOOST_CHECK_EQUAL(encryptedNonce.getAlgorithmType(), tlv::AlgorithmRsaOaep);
 
-  algo::EncryptParams decryptParams(tlv::AlgorithmRsaOaep);
   const Buffer& bufferNonce = encryptedNonce.getPayload();
-  Buffer nonce = algo::Rsa::decrypt(decryptKeyBuf.buf(), decryptKeyBuf.size(),
-                                    bufferNonce.buf(), bufferNonce.size(), decryptParams);
 
+  Buffer nonce = algo::Rsa::decrypt(decryptKeyBuf.data(),
+                                    decryptKeyBuf.size(),
+                                    bufferNonce.data(),
+                                    bufferNonce.size());
   // get buffer payload
   contentIterator++;
   Block payloadContent(*contentIterator);
@@ -321,34 +333,37 @@
   BOOST_CHECK_EQUAL(encryptedPayload.getInitialVector().size(), 16);
   BOOST_CHECK_EQUAL(encryptedPayload.getAlgorithmType(), tlv::AlgorithmAesCbc);
 
-  decryptParams.setAlgorithmType(tlv::AlgorithmAesCbc);
-  decryptParams.setIV(encryptedPayload.getInitialVector().buf(),
+  algo::EncryptParams decryptParams(tlv::AlgorithmAesCbc);
+  decryptParams.setIV(encryptedPayload.getInitialVector().data(),
                       encryptedPayload.getInitialVector().size());
   const Buffer& bufferPayload = encryptedPayload.getPayload();
-  Buffer largePayload = algo::Aes::decrypt(nonce.buf(), nonce.size(),
-                                           bufferPayload.buf(), bufferPayload.size(),
+  Buffer largePayload = algo::Aes::decrypt(nonce.data(),
+                                           nonce.size(),
+                                           bufferPayload.data(),
+                                           bufferPayload.size(),
                                            decryptParams);
 
   // get group D-KEY
-  DecryptKey<algo::Rsa> groupDKey(Buffer(largePayload.buf(), largePayload.size()));
+  DecryptKey<algo::Rsa> groupDKey(Buffer(largePayload.data(), largePayload.size()));
 
   /////////////////////////////////////////////////////////////////////// end decryption
 
   // check the D-KEY
   EncryptKey<algo::Rsa> derivedGroupEKey = algo::Rsa::deriveEncryptKey(groupDKey.getKeyBits());
-  BOOST_CHECK_EQUAL_COLLECTIONS(groupEKey.getKeyBits().begin(), groupEKey.getKeyBits().end(),
+  BOOST_CHECK_EQUAL_COLLECTIONS(groupEKey.getKeyBits().begin(),
+                                groupEKey.getKeyBits().end(),
                                 derivedGroupEKey.getKeyBits().begin(),
                                 derivedGroupEKey.getKeyBits().end());
 
   // third data and decrypt
   dataIterator++;
   BOOST_CHECK_EQUAL(dataIterator->getName().toUri(),
-                    "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberB/ksk-123");
+                    "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberB/KEY/ksk-123");
 
   // second data and decrypt
   dataIterator++;
   BOOST_CHECK_EQUAL(dataIterator->getName().toUri(),
-                    "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberC/ksk-123");
+                    "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberC/KEY/ksk-123");
 
   // invalid time stamp to get group key
   TimeStamp tp2(from_iso_string("20150826T083000"));
@@ -378,13 +393,13 @@
   std::list<Data>::iterator dataIterator1 = result1.begin();
   BOOST_CHECK_EQUAL(dataIterator1->getName().toUri(),
                     "/Alice/READ/data_type/E-KEY/20150825T090000/20150825T100000");
-  EncryptKey<algo::Rsa> groupEKey1(Buffer(dataIterator1->getContent().value(),
-                                         dataIterator1->getContent().value_size()));
+  EncryptKey<algo::Rsa> groupEKey1(
+    Buffer(dataIterator1->getContent().value(), dataIterator1->getContent().value_size()));
 
   // second data
   dataIterator1++;
   BOOST_CHECK_EQUAL(dataIterator1->getName().toUri(),
-                    "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/ksk-123");
+                    "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/KEY/ksk-123");
 
   // add new members to the database
   Block dataBlock = cert.wireEncode();
@@ -399,19 +414,21 @@
   std::list<Data>::iterator dataIterator2 = result2.begin();
   BOOST_CHECK_EQUAL(dataIterator2->getName().toUri(),
                     "/Alice/READ/data_type/E-KEY/20150825T090000/20150825T100000");
-  EncryptKey<algo::Rsa> groupEKey2(Buffer(dataIterator2->getContent().value(),
-                                         dataIterator2->getContent().value_size()));
-  BOOST_CHECK_EQUAL_COLLECTIONS(groupEKey1.getKeyBits().begin(), groupEKey1.getKeyBits().end(),
-                                groupEKey2.getKeyBits().begin(), groupEKey2.getKeyBits().end());
+  EncryptKey<algo::Rsa> groupEKey2(
+    Buffer(dataIterator2->getContent().value(), dataIterator2->getContent().value_size()));
+  BOOST_CHECK_EQUAL_COLLECTIONS(groupEKey1.getKeyBits().begin(),
+                                groupEKey1.getKeyBits().end(),
+                                groupEKey2.getKeyBits().begin(),
+                                groupEKey2.getKeyBits().end());
 
   // second data
   dataIterator2++;
   BOOST_CHECK_EQUAL(dataIterator2->getName().toUri(),
-                    "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/ksk-123");
+                    "/Alice/READ/data_type/D-KEY/20150825T090000/20150825T100000/FOR/ndn/memberA/KEY/ksk-123");
 }
 
 BOOST_AUTO_TEST_SUITE_END()
 
-} // namespace test
+} // namespace tests
 } // namespace gep
 } // namespace ndn
diff --git a/tests/unit-tests/interval.t.cpp b/tests/unit-tests/interval.t.cpp
index e9cf6d9..c50384a 100644
--- a/tests/unit-tests/interval.t.cpp
+++ b/tests/unit-tests/interval.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,7 +16,7 @@
  * You should have received a copy of the GNU General Public License along with
  * ndn-group-encrypt, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  *
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
  */
 
 #include "interval.hpp"
@@ -33,8 +33,7 @@
 BOOST_AUTO_TEST_CASE(Construction)
 {
   // construct with the right parameters
-  Interval interval1(from_iso_string("20150825T120000"),
-                     from_iso_string("20150825T160000"));
+  Interval interval1(from_iso_string("20150825T120000"), from_iso_string("20150825T160000"));
   BOOST_CHECK_EQUAL(to_iso_string(interval1.getStartTime()), "20150825T120000");
   BOOST_CHECK_EQUAL(to_iso_string(interval1.getEndTime()), "20150825T160000");
   BOOST_CHECK_EQUAL(interval1.isValid(), true);
@@ -51,8 +50,7 @@
 
 BOOST_AUTO_TEST_CASE(CoverTimePoint)
 {
-  Interval interval(from_iso_string("20150825T120000"),
-                    from_iso_string("20150825T160000"));
+  Interval interval(from_iso_string("20150825T120000"), from_iso_string("20150825T160000"));
 
   TimeStamp tp1 = from_iso_string("20150825T120000");
   TimeStamp tp2 = from_iso_string("20150825T130000");
@@ -67,23 +65,17 @@
 
 BOOST_AUTO_TEST_CASE(IntersectionAndUnion)
 {
-  Interval interval1(from_iso_string("20150825T030000"),
-                     from_iso_string("20150825T050000"));
+  Interval interval1(from_iso_string("20150825T030000"), from_iso_string("20150825T050000"));
   // no intersection
-  Interval interval2(from_iso_string("20150825T050000"),
-                     from_iso_string("20150825T070000"));
+  Interval interval2(from_iso_string("20150825T050000"), from_iso_string("20150825T070000"));
   // no intersection
-  Interval interval3(from_iso_string("20150825T060000"),
-                     from_iso_string("20150825T070000"));
+  Interval interval3(from_iso_string("20150825T060000"), from_iso_string("20150825T070000"));
   // there's an intersection
-  Interval interval4(from_iso_string("20150825T010000"),
-                     from_iso_string("20150825T040000"));
+  Interval interval4(from_iso_string("20150825T010000"), from_iso_string("20150825T040000"));
   // right in the interval1, there's an intersection
-  Interval interval5(from_iso_string("20150825T030000"),
-                     from_iso_string("20150825T040000"));
+  Interval interval5(from_iso_string("20150825T030000"), from_iso_string("20150825T040000"));
   // wrap the interval1, there's an intersection
-  Interval interval6(from_iso_string("20150825T010000"),
-                     from_iso_string("20150825T050000"));
+  Interval interval6(from_iso_string("20150825T010000"), from_iso_string("20150825T050000"));
   // empty interval
   Interval interval7(true);
 
diff --git a/tests/unit-tests/producer-db.t.cpp b/tests/unit-tests/producer-db.t.cpp
index bcf09e0..881f40e 100644
--- a/tests/unit-tests/producer-db.t.cpp
+++ b/tests/unit-tests/producer-db.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -20,8 +20,8 @@
  */
 
 #include "producer-db.hpp"
-#include "algo/aes.hpp"
 #include "boost-test.hpp"
+#include "algo/aes.hpp"
 
 #include <boost/filesystem.hpp>
 
@@ -59,10 +59,9 @@
   ProducerDB db(dbDir);
 
   // create member
-  RandomNumberGenerator rng;
   AesKeyParams params(128);
-  Buffer keyBuf1 = algo::Aes::generateKey(rng, params).getKeyBits();
-  Buffer keyBuf2 = algo::Aes::generateKey(rng, params).getKeyBits();
+  Buffer keyBuf1 = algo::Aes::generateKey(params).getKeyBits();
+  Buffer keyBuf2 = algo::Aes::generateKey(params).getKeyBits();
 
   system_clock::TimePoint point1(time::fromIsoString("20150101T100000"));
   system_clock::TimePoint point2(time::fromIsoString("20150102T100000"));
@@ -85,16 +84,10 @@
 
   // get content key
   Buffer keyResult = db.getContentKey(point1);
-  BOOST_CHECK_EQUAL_COLLECTIONS(keyResult.begin(),
-                                keyResult.end(),
-                                keyBuf1.begin(),
-                                keyBuf1.end());
+  BOOST_CHECK_EQUAL_COLLECTIONS(keyResult.begin(), keyResult.end(), keyBuf1.begin(), keyBuf1.end());
 
   keyResult = db.getContentKey(point3);
-  BOOST_CHECK_EQUAL_COLLECTIONS(keyResult.begin(),
-                                keyResult.end(),
-                                keyBuf2.begin(),
-                                keyBuf2.end());
+  BOOST_CHECK_EQUAL_COLLECTIONS(keyResult.begin(), keyResult.end(), keyBuf2.begin(), keyBuf2.end());
 
   // throw exception when there is no such timeslot in database
   BOOST_CHECK_THROW(db.getContentKey(point4), ProducerDB::Error);
diff --git a/tests/unit-tests/producer.t.cpp b/tests/unit-tests/producer.t.cpp
old mode 100755
new mode 100644
index 37d08d2..87bddaa
--- a/tests/unit-tests/producer.t.cpp
+++ b/tests/unit-tests/producer.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2016,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -18,16 +18,13 @@
  */
 
 #include "producer.hpp"
-#include "algo/encryptor.hpp"
-#include "algo/rsa.hpp"
-#include "algo/aes.hpp"
 #include "encrypted-content.hpp"
 #include "unit-test-time-fixture.hpp"
-#include "random-number-generator.hpp"
-
-#include <ndn-cxx/util/dummy-client-face.hpp>
-
+#include "algo/aes.hpp"
+#include "algo/encryptor.hpp"
+#include "algo/rsa.hpp"
 #include "boost-test.hpp"
+#include <ndn-cxx/util/dummy-client-face.hpp>
 #include <boost/asio.hpp>
 #include <boost/filesystem.hpp>
 
@@ -35,12 +32,10 @@
 namespace gep {
 namespace tests {
 
-static const uint8_t DATA_CONTEN[] = {
-  0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23,
-  0x84, 0x14, 0x15, 0x61, 0x80, 0xb9, 0x5e, 0xbd,
-  0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91, 0x31, 0xd6,
-  0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c
-};
+static const uint8_t DATA_CONTEN[] = {0xcb, 0xe5, 0x6a, 0x80, 0x41, 0x24, 0x58, 0x23,
+                                      0x84, 0x14, 0x15, 0x61, 0x80, 0xb9, 0x5e, 0xbd,
+                                      0xce, 0x32, 0xb4, 0xbe, 0xbc, 0x91, 0x31, 0xd6,
+                                      0x19, 0x00, 0x80, 0x8b, 0xfa, 0x00, 0x05, 0x9c};
 
 class ProducerFixture : public UnitTestTimeFixture
 {
@@ -65,16 +60,15 @@
   void
   createEncryptionKey(Name eKeyName, const Name& timeMarker)
   {
-    RandomNumberGenerator rng;
     RsaKeyParams params;
     eKeyName.append(timeMarker);
 
-    Buffer dKeyBuf = algo::Rsa::generateKey(rng, params).getKeyBits();
+    Buffer dKeyBuf = algo::Rsa::generateKey(params).getKeyBits();
     Buffer eKeyBuf = algo::Rsa::deriveEncryptKey(dKeyBuf).getKeyBits();
     decryptionKeys[eKeyName] = dKeyBuf;
 
     shared_ptr<Data> keyData = make_shared<Data>(eKeyName);
-    keyData->setContent(eKeyBuf.buf(), eKeyBuf.size());
+    keyData->setContent(eKeyBuf.data(), eKeyBuf.size());
     keyChain.sign(*keyData);
     encryptionKeys[eKeyName] = keyData;
   }
@@ -156,16 +150,17 @@
   }
 
   face2.setInterestFilter(prefix,
-        [&] (const InterestFilter&, const Interest& i) {
-           Name interestName = i.getName();
-           interestName.append(timeMarker);
-           BOOST_REQUIRE_EQUAL(encryptionKeys.find(interestName) !=
-                               encryptionKeys.end(), true);
-           face2.put(*(encryptionKeys[interestName]));
-           return;
-        },
-        RegisterPrefixSuccessCallback(),
-        [] (const Name&, const std::string& e) { });
+                          [&] (const InterestFilter&, const Interest& i) {
+                            Name interestName = i.getName();
+                            interestName.append(timeMarker);
+                            BOOST_REQUIRE_EQUAL(encryptionKeys.find(interestName) !=
+                                                  encryptionKeys.end(),
+                                                true);
+                            face2.put(*(encryptionKeys[interestName]));
+                            return;
+                          },
+                          RegisterPrefixSuccessCallback(),
+                          [] (const Name&, const std::string& e) {});
 
   do {
     advanceClocks(time::milliseconds(10), 20);
@@ -177,50 +172,46 @@
   ProducerDB testDb(dbDir);
   Buffer contentKey;
 
-  auto checkEncryptionKeys =
-          [&](const std::vector<Data>& result,
-              const time::system_clock::TimePoint& testTime,
-              const name::Component& roundedTime) {
-            BOOST_CHECK_EQUAL(testDb.hasContentKey(testTime), true);
-            contentKey = testDb.getContentKey(testTime);
+  auto checkEncryptionKeys = [&] (const std::vector<Data>& result,
+                                 const time::system_clock::TimePoint& testTime,
+                                 const name::Component& roundedTime) {
+    BOOST_CHECK_EQUAL(testDb.hasContentKey(testTime), true);
+    contentKey = testDb.getContentKey(testTime);
 
-            algo::EncryptParams params(tlv::AlgorithmRsaOaep);
-            std::vector<Data>::const_iterator it;
-            for (it = result.begin(); it != result.end(); ++it) {
-              Name keyName = it->getName();
-              BOOST_CHECK_EQUAL(keyName.getSubName(0,6), cKeyName);
-              BOOST_CHECK_EQUAL(keyName.get(6), roundedTime);
-              BOOST_CHECK_EQUAL(keyName.get(7), NAME_COMPONENT_FOR);
-              BOOST_CHECK_EQUAL(decryptionKeys.find(keyName.getSubName(8)) !=
-                                decryptionKeys.end(), true);
-              Name testName = it->getName().getSubName(-8);
-              Buffer decryptionKey;
+    std::vector<Data>::const_iterator it;
+    for (it = result.begin(); it != result.end(); ++it) {
+      Name keyName = it->getName();
+      BOOST_CHECK_EQUAL(keyName.getSubName(0, 6), cKeyName);
+      BOOST_CHECK_EQUAL(keyName.get(6), roundedTime);
+      BOOST_CHECK_EQUAL(keyName.get(7), NAME_COMPONENT_FOR);
+      BOOST_CHECK_EQUAL(decryptionKeys.find(keyName.getSubName(8)) != decryptionKeys.end(), true);
+      Name testName = it->getName().getSubName(-8);
+      Buffer decryptionKey;
 
-              decryptionKey = decryptionKeys.at(keyName.getSubName(8));
-              BOOST_CHECK_EQUAL(decryptionKey.size() != 0, true);
-              Block encryptedKeyBlock = it->getContent();
-              encryptedKeyBlock.parse();
+      decryptionKey = decryptionKeys.at(keyName.getSubName(8));
+      BOOST_CHECK_EQUAL(decryptionKey.size() != 0, true);
+      Block encryptedKeyBlock = it->getContent();
+      encryptedKeyBlock.parse();
 
-              EncryptedContent content(*(encryptedKeyBlock.elements_begin()));
-              const Buffer& encryptedKey = content.getPayload();
-              Buffer retrievedKey = algo::Rsa::decrypt(decryptionKey.buf(),
-                                                       decryptionKey.size(),
-                                                       encryptedKey.buf(),
-                                                       encryptedKey.size(),
-                                                       params);
+      EncryptedContent content(*(encryptedKeyBlock.elements_begin()));
+      const Buffer& encryptedKey = content.getPayload();
+      Buffer retrievedKey = algo::Rsa::decrypt(decryptionKey.data(),
+                                               decryptionKey.size(),
+                                               encryptedKey.data(),
+                                               encryptedKey.size());
 
-              BOOST_CHECK_EQUAL_COLLECTIONS(contentKey.begin(),
-                                            contentKey.end(),
-                                            retrievedKey.begin(),
-                                            retrievedKey.end());
-            }
-            BOOST_CHECK_EQUAL(result.size(), 3);
-          };
+      BOOST_CHECK_EQUAL_COLLECTIONS(contentKey.begin(),
+                                    contentKey.end(),
+                                    retrievedKey.begin(),
+                                    retrievedKey.end());
+    }
+    BOOST_CHECK_EQUAL(result.size(), 3);
+  };
 
   // Initial test to confirm that keys are created for this timeslot
   Name contentKeyName1 =
-      producer.createContentKey(testTime1,
-      std::bind(checkEncryptionKeys, _1, testTime1, testTimeRounded1));
+    producer.createContentKey(testTime1,
+                              std::bind(checkEncryptionKeys, _1, testTime1, testTimeRounded1));
 
   do {
     advanceClocks(time::milliseconds(10), 20);
@@ -228,8 +219,8 @@
 
   // Verify that we do not repeat the search for e-keys, don't advance clock
   Name contentKeyName2 =
-      producer.createContentKey(testTime2,
-      std::bind(checkEncryptionKeys, _1, testTime2, testTimeRounded2));
+    producer.createContentKey(testTime2,
+                              std::bind(checkEncryptionKeys, _1, testTime2, testTimeRounded2));
 
   // Confirm content key names are correct
   BOOST_CHECK_EQUAL(contentKeyName1.getPrefix(-1), cKeyName);
@@ -242,10 +233,10 @@
   producer.produce(testData, testTime2, DATA_CONTEN, sizeof(DATA_CONTEN));
 
   Name producedName = testData.getName();
-  BOOST_CHECK_EQUAL(producedName.getSubName(0,5), cKeyName.getPrefix(-1));
+  BOOST_CHECK_EQUAL(producedName.getSubName(0, 5), cKeyName.getPrefix(-1));
   BOOST_CHECK_EQUAL(producedName.get(5), testTimeComponent2);
   BOOST_CHECK_EQUAL(producedName.get(6), NAME_COMPONENT_FOR);
-  BOOST_CHECK_EQUAL(producedName.getSubName(7,6), cKeyName);
+  BOOST_CHECK_EQUAL(producedName.getSubName(7, 6), cKeyName);
   BOOST_CHECK_EQUAL(producedName.get(13), testTimeRounded2);
 
   Block dataBlock = testData.getContent();
@@ -256,9 +247,9 @@
   const Buffer& iv = dataContent.getInitialVector();
 
   algo::EncryptParams params(tlv::AlgorithmAesCbc, 16);
-  params.setIV(iv.buf(), iv.size());
-  Buffer decryptTest = algo::Aes::decrypt(contentKey.buf(), contentKey.size(),
-                                          encData.buf(), encData.size(), params);
+  params.setIV(iv.data(), iv.size());
+  Buffer decryptTest =
+    algo::Aes::decrypt(contentKey.data(), contentKey.size(), encData.data(), encData.size(), params);
   BOOST_CHECK_EQUAL_COLLECTIONS(decryptTest.begin(),
                                 decryptTest.end(),
                                 DATA_CONTEN,
@@ -295,31 +286,31 @@
 
   size_t requestCount = 0;
   face2.setInterestFilter(prefix,
-        [&] (const InterestFilter&, const Interest& i) {
-           BOOST_REQUIRE_EQUAL(i.getName(), expectedInterest);
-           Name interestName = i.getName();
-           switch(requestCount) {
-             case 0:
-               interestName.append(timeMarkerFirstHop);
-               break;
+                          [&] (const InterestFilter&, const Interest& i) {
+                            BOOST_REQUIRE_EQUAL(i.getName(), expectedInterest);
+                            Name interestName = i.getName();
+                            switch (requestCount) {
+                              case 0:
+                                interestName.append(timeMarkerFirstHop);
+                                break;
 
-             case 1:
-               interestName.append(timeMarkerSecondHop);
-               break;
+                              case 1:
+                                interestName.append(timeMarkerSecondHop);
+                                break;
 
-             case 2:
-               interestName.append(timeMarkerThirdHop);
-               break;
+                              case 2:
+                                interestName.append(timeMarkerThirdHop);
+                                break;
 
-             default:
-               break;
-           }
-           face2.put(*(encryptionKeys[interestName]));
-           requestCount++;
-           return;
-        },
-        RegisterPrefixSuccessCallback(),
-        [] (const Name&, const std::string& e) { });
+                              default:
+                                break;
+                            }
+                            face2.put(*(encryptionKeys[interestName]));
+                            requestCount++;
+                            return;
+                          },
+                          RegisterPrefixSuccessCallback(),
+                          [] (const Name&, const std::string& e) {});
 
   do {
     advanceClocks(time::milliseconds(10), 20);
@@ -328,19 +319,17 @@
   // Verify that if a key is found, but not within the right timeslot, the search
   // is refined until a valid timeslot is found.
   Producer producer(prefix, suffix, face1, dbDir);
-  producer.createContentKey(testTime,
-          [&](const std::vector<Data>& result){
-            BOOST_CHECK_EQUAL(requestCount, 3);
-            BOOST_CHECK_EQUAL(result.size(), 1);
+  producer.createContentKey(testTime, [&] (const std::vector<Data>& result) {
+    BOOST_CHECK_EQUAL(requestCount, 3);
+    BOOST_CHECK_EQUAL(result.size(), 1);
 
-            Data keyData = result[0];
-            Name keyName = keyData.getName();
-            BOOST_CHECK_EQUAL(keyName.getSubName(0,4), cKeyName);
-            BOOST_CHECK_EQUAL(keyName.get(4), timeMarkerThirdHop[0]);
-            BOOST_CHECK_EQUAL(keyName.get(5), NAME_COMPONENT_FOR);
-            BOOST_CHECK_EQUAL(keyName.getSubName(6),
-                              expectedInterest.append(timeMarkerThirdHop));
-          });
+    Data keyData = result[0];
+    Name keyName = keyData.getName();
+    BOOST_CHECK_EQUAL(keyName.getSubName(0, 4), cKeyName);
+    BOOST_CHECK_EQUAL(keyName.get(4), timeMarkerThirdHop[0]);
+    BOOST_CHECK_EQUAL(keyName.get(5), NAME_COMPONENT_FOR);
+    BOOST_CHECK_EQUAL(keyName.getSubName(6), expectedInterest.append(timeMarkerThirdHop));
+  });
   do {
     advanceClocks(time::milliseconds(10), 20);
   } while (passPacket());
@@ -362,13 +351,13 @@
 
   size_t timeoutCount = 0;
   face2.setInterestFilter(prefix,
-        [&] (const InterestFilter&, const Interest& i) {
-           BOOST_CHECK_EQUAL(i.getName(), expectedInterest);
-           timeoutCount++;
-           return;
-        },
-        RegisterPrefixSuccessCallback(),
-        [] (const Name&, const std::string& e) { });
+                          [&] (const InterestFilter&, const Interest& i) {
+                            BOOST_CHECK_EQUAL(i.getName(), expectedInterest);
+                            timeoutCount++;
+                            return;
+                          },
+                          RegisterPrefixSuccessCallback(),
+                          [] (const Name&, const std::string& e) {});
 
   do {
     advanceClocks(time::milliseconds(10), 20);
@@ -377,11 +366,10 @@
   // Verify that if no response is received, the producer appropriately times out.
   // The result vector should not contain elements that have timed out.
   Producer producer(prefix, suffix, face1, dbDir);
-  producer.createContentKey(testTime,
-          [&](const std::vector<Data>& result){
-            BOOST_CHECK_EQUAL(timeoutCount, 4);
-            BOOST_CHECK_EQUAL(result.size(), 0);
-          });
+  producer.createContentKey(testTime, [&] (const std::vector<Data>& result) {
+    BOOST_CHECK_EQUAL(timeoutCount, 4);
+    BOOST_CHECK_EQUAL(result.size(), 0);
+  });
 
   do {
     advanceClocks(time::milliseconds(10), 500);
@@ -404,14 +392,14 @@
 
   size_t timeoutCount = 0;
   face2.setInterestFilter(prefix,
-        [&] (const InterestFilter&, const Interest& i) {
-           BOOST_CHECK_EQUAL(i.getName(), expectedInterest);
-           BOOST_CHECK(i.getLink().getDelegations().size() == 3);
-           timeoutCount++;
-           return;
-        },
-        RegisterPrefixSuccessCallback(),
-        [] (const Name&, const std::string& e) { });
+                          [&] (const InterestFilter&, const Interest& i) {
+                            BOOST_CHECK_EQUAL(i.getName(), expectedInterest);
+                            BOOST_CHECK(i.getForwardingHint().size() == 3);
+                            timeoutCount++;
+                            return;
+                          },
+                          RegisterPrefixSuccessCallback(),
+                          [] (const Name&, const std::string& e) {});
 
   do {
     advanceClocks(time::milliseconds(10), 20);
@@ -422,11 +410,10 @@
   Link link("test", {{10, "/test1"}, {20, "/test2"}, {100, "/test3"}});
   keyChain.sign(link);
   Producer producer(prefix, suffix, face1, dbDir, 3, link);
-  producer.createContentKey(testTime,
-          [&](const std::vector<Data>& result){
-            BOOST_CHECK_EQUAL(timeoutCount, 4);
-            BOOST_CHECK_EQUAL(result.size(), 0);
-          });
+  producer.createContentKey(testTime, [&] (const std::vector<Data>& result) {
+    BOOST_CHECK_EQUAL(timeoutCount, 4);
+    BOOST_CHECK_EQUAL(result.size(), 0);
+  });
 
   do {
     advanceClocks(time::milliseconds(10), 800);
diff --git a/tests/unit-tests/repetitive-interval.t.cpp b/tests/unit-tests/repetitive-interval.t.cpp
index 51abdf8..d5baa21 100644
--- a/tests/unit-tests/repetitive-interval.t.cpp
+++ b/tests/unit-tests/repetitive-interval.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,7 +16,7 @@
  * You should have received a copy of the GNU General Public License along with
  * ndn-group-encrypt, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  *
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
  */
 
 #include "repetitive-interval.hpp"
@@ -34,7 +34,8 @@
 {
   RepetitiveInterval repetitiveInterval1(from_iso_string("20150825T000000"),
                                          from_iso_string("20150825T000000"),
-                                         5, 10);
+                                         5,
+                                         10);
 
   BOOST_CHECK_EQUAL(to_iso_string(repetitiveInterval1.getStartDate()), "20150825T000000");
   BOOST_CHECK_EQUAL(to_iso_string(repetitiveInterval1.getEndDate()), "20150825T000000");
@@ -43,21 +44,30 @@
 
   RepetitiveInterval repetitiveInterval2(from_iso_string("20150825T000000"),
                                          from_iso_string("20150827T000000"),
-                                         5, 10, 1, RepetitiveInterval::RepeatUnit::DAY);
+                                         5,
+                                         10,
+                                         1,
+                                         RepetitiveInterval::RepeatUnit::DAY);
 
   BOOST_CHECK_EQUAL(repetitiveInterval2.getNRepeats(), 1);
   BOOST_CHECK(repetitiveInterval2.getRepeatUnit() == RepetitiveInterval::RepeatUnit::DAY);
 
   RepetitiveInterval repetitiveInterval3(from_iso_string("20150825T000000"),
                                          from_iso_string("20151227T000000"),
-                                         5, 10, 2, RepetitiveInterval::RepeatUnit::MONTH);
+                                         5,
+                                         10,
+                                         2,
+                                         RepetitiveInterval::RepeatUnit::MONTH);
 
   BOOST_CHECK_EQUAL(repetitiveInterval3.getNRepeats(), 2);
   BOOST_CHECK(repetitiveInterval3.getRepeatUnit() == RepetitiveInterval::RepeatUnit::MONTH);
 
   RepetitiveInterval repetitiveInterval4(from_iso_string("20150825T000000"),
                                          from_iso_string("20301227T000000"),
-                                         5, 10, 5, RepetitiveInterval::RepeatUnit::YEAR);
+                                         5,
+                                         10,
+                                         5,
+                                         RepetitiveInterval::RepeatUnit::YEAR);
 
   BOOST_CHECK_EQUAL(repetitiveInterval4.getNRepeats(), 5);
   BOOST_CHECK(repetitiveInterval4.getRepeatUnit() == RepetitiveInterval::RepeatUnit::YEAR);
@@ -74,20 +84,23 @@
 
   RepetitiveInterval repetitiveInterval1(from_iso_string("20150825T000000"),
                                          from_iso_string("20150925T000000"),
-                                         5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+                                         5,
+                                         10,
+                                         2,
+                                         RepetitiveInterval::RepeatUnit::DAY);
   Interval resultInterval;
   bool isPositive = false;
 
   TimeStamp tp1 = from_iso_string("20150825T050000");
 
-  std::tie(isPositive,resultInterval) = repetitiveInterval1.getInterval(tp1);
+  std::tie(isPositive, resultInterval) = repetitiveInterval1.getInterval(tp1);
   BOOST_CHECK_EQUAL(isPositive, true);
   BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20150825T050000");
   BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20150825T100000");
 
   TimeStamp tp2 = from_iso_string("20150902T060000");
 
-  std::tie(isPositive,resultInterval) = repetitiveInterval1.getInterval(tp2);
+  std::tie(isPositive, resultInterval) = repetitiveInterval1.getInterval(tp2);
   BOOST_CHECK_EQUAL(isPositive, true);
   BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20150902T050000");
   BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20150902T100000");
@@ -100,21 +113,24 @@
 
   RepetitiveInterval repetitiveInterval2(from_iso_string("20150825T000000"),
                                          from_iso_string("20160825T000000"),
-                                         5, 10, 2, RepetitiveInterval::RepeatUnit::MONTH);
+                                         5,
+                                         10,
+                                         2,
+                                         RepetitiveInterval::RepeatUnit::MONTH);
 
   TimeStamp tp4 = from_iso_string("20150825T050000");
 
-  std::tie(isPositive,resultInterval) = repetitiveInterval2.getInterval(tp4);
+  std::tie(isPositive, resultInterval) = repetitiveInterval2.getInterval(tp4);
   BOOST_CHECK_EQUAL(isPositive, true);
   BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20150825T050000");
   BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20150825T100000");
 
   TimeStamp tp5 = from_iso_string("20151025T060000");
 
-  std::tie(isPositive,resultInterval) = repetitiveInterval2.getInterval(tp5);
+  std::tie(isPositive, resultInterval) = repetitiveInterval2.getInterval(tp5);
   BOOST_CHECK_EQUAL(isPositive, true);
   BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20151025T050000");
-  BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()),  "20151025T100000");
+  BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20151025T100000");
 
   TimeStamp tp6 = from_iso_string("20151226T050000");
 
@@ -128,18 +144,21 @@
 
   RepetitiveInterval repetitiveInterval3(from_iso_string("20150825T000000"),
                                          from_iso_string("20300825T000000"),
-                                         5, 10, 3, RepetitiveInterval::RepeatUnit::YEAR);
+                                         5,
+                                         10,
+                                         3,
+                                         RepetitiveInterval::RepeatUnit::YEAR);
 
   TimeStamp tp8 = from_iso_string("20150825T050000");
 
-  std::tie(isPositive,resultInterval) = repetitiveInterval3.getInterval(tp8);
+  std::tie(isPositive, resultInterval) = repetitiveInterval3.getInterval(tp8);
   BOOST_CHECK_EQUAL(isPositive, true);
   BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20150825T050000");
   BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20150825T100000");
 
   TimeStamp tp9 = from_iso_string("20180825T060000");
 
-  std::tie(isPositive,resultInterval) = repetitiveInterval3.getInterval(tp9);
+  std::tie(isPositive, resultInterval) = repetitiveInterval3.getInterval(tp9);
   BOOST_CHECK_EQUAL(isPositive, true);
   BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getStartTime()), "20180825T050000");
   BOOST_CHECK_EQUAL(to_iso_string(resultInterval.getEndTime()), "20180825T100000");
@@ -154,27 +173,21 @@
   BOOST_CHECK(std::get<0>(repetitiveInterval3.getInterval(tp12)) == false);
 }
 
-const uint8_t REPETITIVE_INTERVAL[] = {
-  0x8c, 0x2e, // RepetitiveInterval
-    0x86, 0x0f,
-      0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x35, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
-    0x87, 0x0f,
-      0x32, 0x30, 0x31, 0x35, 0x30, 0x39, 0x32, 0x31, 0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
-    0x88, 0x01,
-      0x05,
-    0x89, 0x01,
-      0x0a,
-    0x8a, 0x01,
-      0x04,
-    0x8b, 0x01,
-      0x01
-};
+const uint8_t REPETITIVE_INTERVAL[] = {0x8c, 0x2e, // RepetitiveInterval
+                                       0x86, 0x0f, 0x32, 0x30, 0x31, 0x35, 0x30, 0x38, 0x32, 0x35,
+                                       0x54, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x87, 0x0f, 0x32,
+                                       0x30, 0x31, 0x35, 0x30, 0x39, 0x32, 0x31, 0x54, 0x30, 0x30,
+                                       0x30, 0x30, 0x30, 0x30, 0x88, 0x01, 0x05, 0x89, 0x01, 0x0a,
+                                       0x8a, 0x01, 0x04, 0x8b, 0x01, 0x01};
 
 BOOST_AUTO_TEST_CASE(EncodeAndDecode)
 {
   RepetitiveInterval repetitiveInterval1(from_iso_string("20150825T000000"),
                                          from_iso_string("20150921T000000"),
-                                         5, 10, 4, RepetitiveInterval::RepeatUnit::DAY);
+                                         5,
+                                         10,
+                                         4,
+                                         RepetitiveInterval::RepeatUnit::DAY);
 
   Block block1 = repetitiveInterval1.wireEncode();
   Block block2(REPETITIVE_INTERVAL, sizeof(REPETITIVE_INTERVAL));
@@ -203,45 +216,75 @@
 static bool
 check(const RepetitiveInterval& small, const RepetitiveInterval& big)
 {
-  return  (small < big && !(big < small));
+  return (small < big && !(big < small));
 }
 
 BOOST_AUTO_TEST_CASE(Comparison)
 {
   BOOST_CHECK(check(RepetitiveInterval(from_iso_string("20150825T000000"),
                                        from_iso_string("20150828T000000"),
-                                       5, 10, 2, RepetitiveInterval::RepeatUnit::DAY),
+                                       5,
+                                       10,
+                                       2,
+                                       RepetitiveInterval::RepeatUnit::DAY),
                     RepetitiveInterval(from_iso_string("20150826T000000"),
                                        from_iso_string("20150828T000000"),
-                                       5, 10, 2, RepetitiveInterval::RepeatUnit::DAY)));
+                                       5,
+                                       10,
+                                       2,
+                                       RepetitiveInterval::RepeatUnit::DAY)));
 
   BOOST_CHECK(check(RepetitiveInterval(from_iso_string("20150825T000000"),
                                        from_iso_string("20150828T000000"),
-                                       5, 10, 2, RepetitiveInterval::RepeatUnit::DAY),
+                                       5,
+                                       10,
+                                       2,
+                                       RepetitiveInterval::RepeatUnit::DAY),
                     RepetitiveInterval(from_iso_string("20150825T000000"),
                                        from_iso_string("20150828T000000"),
-                                       6, 10, 2, RepetitiveInterval::RepeatUnit::DAY)));
+                                       6,
+                                       10,
+                                       2,
+                                       RepetitiveInterval::RepeatUnit::DAY)));
 
   BOOST_CHECK(check(RepetitiveInterval(from_iso_string("20150825T000000"),
                                        from_iso_string("20150828T000000"),
-                                       5, 10, 2, RepetitiveInterval::RepeatUnit::DAY),
+                                       5,
+                                       10,
+                                       2,
+                                       RepetitiveInterval::RepeatUnit::DAY),
                     RepetitiveInterval(from_iso_string("20150825T000000"),
                                        from_iso_string("20150828T000000"),
-                                       5, 11, 2, RepetitiveInterval::RepeatUnit::DAY)));
+                                       5,
+                                       11,
+                                       2,
+                                       RepetitiveInterval::RepeatUnit::DAY)));
 
   BOOST_CHECK(check(RepetitiveInterval(from_iso_string("20150825T000000"),
                                        from_iso_string("20150828T000000"),
-                                       5, 10, 2, RepetitiveInterval::RepeatUnit::DAY),
+                                       5,
+                                       10,
+                                       2,
+                                       RepetitiveInterval::RepeatUnit::DAY),
                     RepetitiveInterval(from_iso_string("20150825T000000"),
                                        from_iso_string("20150828T000000"),
-                                       5, 10, 3, RepetitiveInterval::RepeatUnit::DAY)));
+                                       5,
+                                       10,
+                                       3,
+                                       RepetitiveInterval::RepeatUnit::DAY)));
 
   BOOST_CHECK(check(RepetitiveInterval(from_iso_string("20150825T000000"),
                                        from_iso_string("20150828T000000"),
-                                       5, 10, 2, RepetitiveInterval::RepeatUnit::DAY),
+                                       5,
+                                       10,
+                                       2,
+                                       RepetitiveInterval::RepeatUnit::DAY),
                     RepetitiveInterval(from_iso_string("20150825T000000"),
                                        from_iso_string("20150828T000000"),
-                                       5, 10, 2, RepetitiveInterval::RepeatUnit::MONTH)));
+                                       5,
+                                       10,
+                                       2,
+                                       RepetitiveInterval::RepeatUnit::MONTH)));
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/unit-tests/schedule.t.cpp b/tests/unit-tests/schedule.t.cpp
index 1d86787..64c0024 100644
--- a/tests/unit-tests/schedule.t.cpp
+++ b/tests/unit-tests/schedule.t.cpp
@@ -1,6 +1,6 @@
 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
 /**
- * Copyright (c) 2014-2015,  Regents of the University of California
+ * Copyright (c) 2014-2018, Regents of the University of California
  *
  * This file is part of ndn-group-encrypt (Group-based Encryption Protocol for NDN).
  * See AUTHORS.md for complete list of ndn-group-encrypt authors and contributors.
@@ -16,7 +16,7 @@
  * You should have received a copy of the GNU General Public License along with
  * ndn-group-encrypt, e.g., in COPYING.md file.  If not, see <http://www.gnu.org/licenses/>.
  *
- * @author Zhiyi Zhang <dreamerbarrychang@gmail.com>
+ * @author Zhiyi Zhang <zhiyi@cs.ucla.edu>
  */
 
 #include "schedule.hpp"
@@ -35,16 +35,24 @@
   Schedule schedule;
   RepetitiveInterval interval1(from_iso_string("20150825T000000"),
                                from_iso_string("20150827T000000"),
-                               5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+                               5,
+                               10,
+                               2,
+                               RepetitiveInterval::RepeatUnit::DAY);
   RepetitiveInterval interval2(from_iso_string("20150825T000000"),
                                from_iso_string("20150827T000000"),
-                               6, 8, 1, RepetitiveInterval::RepeatUnit::DAY);
+                               6,
+                               8,
+                               1,
+                               RepetitiveInterval::RepeatUnit::DAY);
   RepetitiveInterval interval3(from_iso_string("20150827T000000"),
                                from_iso_string("20150827T000000"),
-                               7, 8);
+                               7,
+                               8);
   RepetitiveInterval interval4(from_iso_string("20150825T000000"),
                                from_iso_string("20150825T000000"),
-                               4, 7);
+                               4,
+                               7);
 
   schedule.addWhiteInterval(interval1);
   schedule.addWhiteInterval(interval2);
@@ -104,13 +112,20 @@
   Schedule schedule;
   RepetitiveInterval interval1(from_iso_string("20150825T000000"),
                                from_iso_string("20150827T000000"),
-                               5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+                               5,
+                               10,
+                               2,
+                               RepetitiveInterval::RepeatUnit::DAY);
   RepetitiveInterval interval2(from_iso_string("20150825T000000"),
                                from_iso_string("20150827T000000"),
-                               6, 8, 1, RepetitiveInterval::RepeatUnit::DAY);
+                               6,
+                               8,
+                               1,
+                               RepetitiveInterval::RepeatUnit::DAY);
   RepetitiveInterval interval3(from_iso_string("20150825T000000"),
                                from_iso_string("20150825T000000"),
-                               4, 7);
+                               4,
+                               7);
 
   schedule.addWhiteInterval(interval1);
   schedule.addWhiteInterval(interval2);
@@ -162,10 +177,16 @@
   Schedule schedule;
   RepetitiveInterval interval1(from_iso_string("20150825T000000"),
                                from_iso_string("20150827T000000"),
-                               5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+                               5,
+                               10,
+                               2,
+                               RepetitiveInterval::RepeatUnit::DAY);
   RepetitiveInterval interval2(from_iso_string("20150825T000000"),
                                from_iso_string("20150827T000000"),
-                               6, 8, 1, RepetitiveInterval::RepeatUnit::DAY);
+                               6,
+                               8,
+                               1,
+                               RepetitiveInterval::RepeatUnit::DAY);
 
   schedule.addBlackInterval(interval1);
   schedule.addBlackInterval(interval2);
@@ -259,16 +280,24 @@
 
   RepetitiveInterval interval1(from_iso_string("20150825T000000"),
                                from_iso_string("20150828T000000"),
-                               5, 10, 2, RepetitiveInterval::RepeatUnit::DAY);
+                               5,
+                               10,
+                               2,
+                               RepetitiveInterval::RepeatUnit::DAY);
   RepetitiveInterval interval2(from_iso_string("20150825T000000"),
                                from_iso_string("20150828T000000"),
-                               6, 8, 1, RepetitiveInterval::RepeatUnit::DAY);
+                               6,
+                               8,
+                               1,
+                               RepetitiveInterval::RepeatUnit::DAY);
   RepetitiveInterval interval3(from_iso_string("20150827T000000"),
                                from_iso_string("20150827T000000"),
-                               7, 8);
+                               7,
+                               8);
   RepetitiveInterval interval4(from_iso_string("20150825T000000"),
                                from_iso_string("20150825T000000"),
-                               4, 7);
+                               4,
+                               7);
 
   schedule.addWhiteInterval(interval1);
   schedule.addWhiteInterval(interval2);