DesEncryptor/DesDecryptor: expose key type.

Expose block ciphers' key sizes for usage in compile-time context.

Chaos/Cipher/Block/Des/DesCrypt.hpp

@@ -198,8 +198,10 @@ class DesCrypt
 public:
     using Block = uint64_t;
     static constexpr size_t BlockSize = 8;
+    static constexpr size_t KeySize = 8;
 
     static_assert(BlockSize == sizeof(Block));
+    static_assert(KeySize == Inner_::RawKey::Size());
 
     DesCrypt() = delete;
 
@@ -231,7 +233,9 @@ public:
     class DesEncryptor : public Encryptor<DesEncryptor>
     {
     public:
+        using Key = DesCrypt::Key;
         static constexpr size_t BlockSize = DesCrypt::BlockSize;
+        static constexpr size_t KeySize = DesCrypt::KeySize;
 
         DesEncryptor(const Key & key)
             : Schedule_(Inner_::KeySchedule::Direction::Encrypt, key.Key_)
@@ -274,7 +278,9 @@ public:
     class DesDecryptor : public Decryptor<DesDecryptor>
     {
     public:
+        using Key = DesCrypt::Key;
         static constexpr size_t BlockSize = DesCrypt::BlockSize;
+        static constexpr size_t KeySize = DesCrypt::KeySize;
 
         DesDecryptor(const Key & key)
             : Schedule_(Inner_::KeySchedule::Direction::Decrypt, key.Key_)

Chaos/Service/SeArray.hpp

@@ -58,11 +58,6 @@ public:
         return Storage_.data() + Storage_.size();
     }
 
-    constexpr size_t Size() const noexcept
-    {
-        return Storage_.size();
-    }
-
     void Fill(const T & value)
     {
         Storage_.fill(value);
@@ -73,6 +68,11 @@ public:
         EraseImpl();
     }
 
+    static constexpr size_t Size() noexcept
+    {
+        return S;
+    }
+
 private:
     std::array<T, S> Storage_;
 

ChaosTests/CMakeLists.txt

@@ -18,7 +18,8 @@ set(ChaosTests_SOURCE Hash/Md4HasherTests.cpp
                       Cipher/Arc4GenTests.cpp
                       Cipher/Arc4CryptTests.cpp
                       Cipher/DesCryptTests.cpp
-                      Service/SeArrayTests.cpp)
+                      Service/SeArrayTests.cpp
+                      Service/ChaosExceptionTests.cpp)
 
 add_executable(ChaosTests ${ChaosTests_SOURCE})
 target_link_libraries(ChaosTests gtest gtest_main)
@@ -26,6 +27,8 @@ target_include_directories(ChaosTests PRIVATE
     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/Chaos>
 )
 
+target_compile_options(ChaosTests PRIVATE -Wunused -Werror=unused)
+
 if(CMAKE_BUILD_TYPE STREQUAL "Debug")
     target_compile_options(ChaosTests PRIVATE --coverage)
     target_link_options(ChaosTests PRIVATE --coverage)

ChaosTests/Cipher/Arc4CryptTests.cpp

@@ -58,11 +58,8 @@ TEST(Arc4CryptTests, UninitializedArc4CryptTest)
     Arc4Crypt arc4;
 
     {
-        std::array<uint8_t, 10> in;
+        std::array<uint8_t, 10> in = {};
-        in.fill(0);
+        std::array<uint8_t, 10> out = {};
-
-        std::array<uint8_t, 10> out;
-        out.fill(0);
 
         ASSERT_THROW(arc4.Encrypt(out.begin(), in.begin(), in.size()), Chaos::Service::ChaosException);
         ASSERT_THROW(arc4.Decrypt(out.begin(), in.begin(), in.size()), Chaos::Service::ChaosException);
@@ -117,8 +114,7 @@ TEST(Arc4CryptTests, EncryptOutIteratorUsageTest)
 
         Arc4Crypt crypt(key.begin(), key.end());
 
-        std::array<uint8_t, 47> out;
+        std::array<uint8_t, 47> out = {};
-        out.fill(0);
 
         std::array<uint8_t, 47> expected =
         {
@@ -139,8 +135,7 @@ TEST(Arc4CryptTests, EncryptOutIteratorUsageTest)
 
         Arc4Crypt crypt(key.begin(), key.end());
 
-        std::array<uint8_t, 47> out;
+        std::array<uint8_t, 47> out = {};
-        out.fill(0);
 
         std::array<uint8_t, 47> expected =
         {
@@ -161,11 +156,8 @@ TEST(Arc4CryptTests, EncryptOutIteratorUsageTest)
 
         Arc4Crypt crypt(key.begin(), key.end());
 
-        std::array<uint8_t, 44> out;
+        std::array<uint8_t, 44> out = {};
-        out.fill(0);
+        std::array<uint8_t, 44> expected = {};
-
-        std::array<uint8_t, 44> expected;
-        expected.fill(0);
 
         crypt.Encrypt(out.begin() + 3, data.begin(), 0);
 
@@ -182,8 +174,7 @@ TEST(Arc4CryptTests, DecryptOutIteratorUsageTest)
     {
         Arc4Crypt crypt(key.begin(), key.end());
 
-        std::array<uint8_t, 17> out;
+        std::array<uint8_t, 17> out = {};
-        out.fill(0);
 
         std::array<uint8_t, 17> expected =
         {
@@ -200,8 +191,7 @@ TEST(Arc4CryptTests, DecryptOutIteratorUsageTest)
     {
         Arc4Crypt crypt(key.begin(), key.end());
 
-        std::array<uint8_t, 17> out;
+        std::array<uint8_t, 17> out = {};
-        out.fill(0);
 
         std::array<uint8_t, 17> expected =
         {
@@ -218,11 +208,8 @@ TEST(Arc4CryptTests, DecryptOutIteratorUsageTest)
     {
         Arc4Crypt crypt(key.begin(), key.end());
 
-        std::array<uint8_t, 14> out;
+        std::array<uint8_t, 14> out = {};
-        out.fill(0);
+        std::array<uint8_t, 14> expected = {};
-
-        std::array<uint8_t, 14> expected;
-        expected.fill(0);
 
         crypt.Decrypt(out.begin() + 3, data.begin(), 0);
 

ChaosTests/Cipher/Arc4GenTests.cpp

@@ -360,8 +360,7 @@ TEST(Arc4GenTests, GenerateOutIteratorUsageTest)
         uint8_t key[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
         Arc4Gen gen(key, key + std::size(key));
 
-        std::array<uint8_t, 23> out;
+        std::array<uint8_t, 23> out = {};
-        out.fill(0);
 
         std::array<uint8_t, 23> expected =
         {
@@ -380,8 +379,7 @@ TEST(Arc4GenTests, GenerateOutIteratorUsageTest)
         uint8_t key[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
         Arc4Gen gen(key, key + std::size(key));
 
-        std::array<uint8_t, 23> out;
+        std::array<uint8_t, 23> out = {};
-        out.fill(0);
 
         std::array<uint8_t, 23> expected =
         {
@@ -400,11 +398,8 @@ TEST(Arc4GenTests, GenerateOutIteratorUsageTest)
         uint8_t key[] = { 0x01, 0x02, 0x03, 0x04, 0x05 };
         Arc4Gen gen(key, key + std::size(key));
 
-        std::array<uint8_t, 20> out;
+        std::array<uint8_t, 20> out = {};
-        out.fill(0);
+        std::array<uint8_t, 20> expected = {};
-
-        std::array<uint8_t, 20> expected;
-        expected.fill(0);
 
         gen.Generate(out.begin() + 3, 0);
 

ChaosTests/Cipher/DesCryptTests.cpp

@@ -44,10 +44,9 @@ TEST(DesCryptTests, EncryptTest)
     struct Helper
     {
         std::array<uint8_t, DesCrypt::BlockSize> operator()(const std::array<uint8_t, DesCrypt::BlockSize> & data,
-                                                            const std::array<uint8_t, 8> & key) const
+                                                            const std::array<uint8_t, DesCrypt::KeySize> & key) const
         {
-            std::array<uint8_t, DesCrypt::BlockSize> result;
+            std::array<uint8_t, DesCrypt::BlockSize> result = {};
-            result.fill(0);
 
             DesCrypt::Key desKey(key.begin(), key.end());
             DesCrypt::DesEncryptor enc(desKey);
@@ -61,7 +60,7 @@ TEST(DesCryptTests, EncryptTest)
 
     {
         std::array<uint8_t, DesCrypt::BlockSize> data = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
-        std::array<uint8_t, 8> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
 
         std::array<uint8_t, DesCrypt::BlockSize> expected = { 0x85, 0xe8, 0x13, 0x54, 0x0f, 0x0a, 0xb4, 0x05 };
 
@@ -70,7 +69,7 @@ TEST(DesCryptTests, EncryptTest)
 
     {
         std::array<uint8_t, DesCrypt::BlockSize> data = { 0xaa, 0xf3, 0x83, 0x16, 0x2d, 0x2e, 0x6b, 0xcb };
-        std::array<uint8_t, 8> key = { 0x44, 0xbf, 0x32, 0x19, 0x99, 0x25, 0x81, 0x51 };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0x44, 0xbf, 0x32, 0x19, 0x99, 0x25, 0x81, 0x51 };
 
         std::array<uint8_t, DesCrypt::BlockSize> expected = { 0x07, 0xe8, 0x7f, 0xaa, 0xb3, 0x17, 0x13, 0x18 };
 
@@ -79,7 +78,7 @@ TEST(DesCryptTests, EncryptTest)
 
     {
         std::array<uint8_t, DesCrypt::BlockSize> data = { 0xe5, 0x1a, 0x9f, 0xd4, 0x19, 0xa7, 0x93, 0x44 };
-        std::array<uint8_t, 8> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
 
         std::array<uint8_t, DesCrypt::BlockSize> expected = { 0x42, 0x27, 0x88, 0xa6, 0x7b, 0x6c, 0x18, 0xed };
 
@@ -92,7 +91,7 @@ TEST(DesCryptTests, EncryptUInt64BlockTest)
     struct Helper
     {
         uint64_t operator()(uint64_t data,
-                            const std::array<uint8_t, 8> & key) const
+                            const std::array<uint8_t, DesCrypt::KeySize> & key) const
         {
             DesCrypt::Key desKey(key.begin(), key.end());
             DesCrypt::DesEncryptor enc(desKey);
@@ -105,7 +104,7 @@ TEST(DesCryptTests, EncryptUInt64BlockTest)
 
     {
         uint64_t data = 0x0123456789abcdef;
-        std::array<uint8_t, 8> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
 
         uint64_t expected = 0x85e813540f0ab405;
 
@@ -114,7 +113,7 @@ TEST(DesCryptTests, EncryptUInt64BlockTest)
 
     {
         uint64_t data = 0xaaf383162d2e6bcb;
-        std::array<uint8_t, 8> key = { 0x44, 0xbf, 0x32, 0x19, 0x99, 0x25, 0x81, 0x51 };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0x44, 0xbf, 0x32, 0x19, 0x99, 0x25, 0x81, 0x51 };
 
         uint64_t expected = 0x07e87faab3171318;
 
@@ -123,7 +122,7 @@ TEST(DesCryptTests, EncryptUInt64BlockTest)
 
     {
         uint64_t data = 0xe51a9fd419a79344;
-        std::array<uint8_t, 8> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
 
         uint64_t expected = 0x422788a67b6c18ed;
 
@@ -204,10 +203,9 @@ TEST(DesCryptTests, DecryptTest)
     struct Helper
     {
         std::array<uint8_t, DesCrypt::BlockSize> operator()(const std::array<uint8_t, DesCrypt::BlockSize> & data,
-                                                            const std::array<uint8_t, 8> & key) const
+                                                            const std::array<uint8_t, DesCrypt::KeySize> & key) const
         {
-            std::array<uint8_t, DesCrypt::BlockSize> result;
+            std::array<uint8_t, DesCrypt::BlockSize> result = {};
-            result.fill(0);
 
             DesCrypt::Key desKey(key.begin(), key.end());
             DesCrypt::DesDecryptor dec(desKey);
@@ -221,7 +219,7 @@ TEST(DesCryptTests, DecryptTest)
 
     {
         std::array<uint8_t, DesCrypt::BlockSize> data = { 0x85, 0xe8, 0x13, 0x54, 0x0f, 0x0a, 0xb4, 0x05 };
-        std::array<uint8_t, 8> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
 
         std::array<uint8_t, DesCrypt::BlockSize> expected = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
 
@@ -230,7 +228,7 @@ TEST(DesCryptTests, DecryptTest)
 
     {
         std::array<uint8_t, DesCrypt::BlockSize> data = { 0x07, 0xe8, 0x7f, 0xaa, 0xb3, 0x17, 0x13, 0x18 };
-        std::array<uint8_t, 8> key = { 0x44, 0xbf, 0x32, 0x19, 0x99, 0x25, 0x81, 0x51 };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0x44, 0xbf, 0x32, 0x19, 0x99, 0x25, 0x81, 0x51 };
 
         std::array<uint8_t, DesCrypt::BlockSize> expected = { 0xaa, 0xf3, 0x83, 0x16, 0x2d, 0x2e, 0x6b, 0xcb };
 
@@ -239,7 +237,7 @@ TEST(DesCryptTests, DecryptTest)
 
     {
         std::array<uint8_t, DesCrypt::BlockSize> data = { 0x42, 0x27, 0x88, 0xa6, 0x7b, 0x6c, 0x18, 0xed };
-        std::array<uint8_t, 8> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
 
         std::array<uint8_t, DesCrypt::BlockSize> expected = { 0xe5, 0x1a, 0x9f, 0xd4, 0x19, 0xa7, 0x93, 0x44 };
 
@@ -252,7 +250,7 @@ TEST(DesCryptTests, DecryptUInt64BlockTest)
     struct Helper
     {
         uint64_t operator()(uint64_t data,
-                            const std::array<uint8_t, 8> & key) const
+                            const std::array<uint8_t, DesCrypt::KeySize> & key) const
         {
             DesCrypt::Key desKey(key.begin(), key.end());
             DesCrypt::DesDecryptor dec(desKey);
@@ -265,7 +263,7 @@ TEST(DesCryptTests, DecryptUInt64BlockTest)
 
     {
         uint64_t data = 0x85e813540f0ab405;
-        std::array<uint8_t, 8> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
 
         uint64_t expected = 0x0123456789abcdef;
 
@@ -274,7 +272,7 @@ TEST(DesCryptTests, DecryptUInt64BlockTest)
 
     {
         uint64_t data = 0x07e87faab3171318;
-        std::array<uint8_t, 8> key = { 0x44, 0xbf, 0x32, 0x19, 0x99, 0x25, 0x81, 0x51 };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0x44, 0xbf, 0x32, 0x19, 0x99, 0x25, 0x81, 0x51 };
 
         uint64_t expected = 0xaaf383162d2e6bcb;
 
@@ -283,7 +281,7 @@ TEST(DesCryptTests, DecryptUInt64BlockTest)
 
     {
         uint64_t data = 0x422788a67b6c18ed;
-        std::array<uint8_t, 8> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
 
         uint64_t expected = 0xe51a9fd419a79344;
 
@@ -362,7 +360,7 @@ TEST(DesCryptTests, DecryptLongDataTest)
 TEST(DesCryptTests, ShortKeyTest)
 {
     {
-        std::array<uint8_t, 7> key = {};
+        std::array<uint8_t, DesCrypt::KeySize - 1> key = {};
         ASSERT_THROW(DesCrypt::Key(key.begin(), key.end()), Chaos::Service::ChaosException);
     }
 }
@@ -370,7 +368,7 @@ TEST(DesCryptTests, ShortKeyTest)
 TEST(DesCryptTests, LongKeyTest)
 {
     {
-        std::array<uint8_t, 9> key = {};
+        std::array<uint8_t, DesCrypt::KeySize + 1> key = {};
         ASSERT_THROW(DesCrypt::Key(key.begin(), key.end()), Chaos::Service::ChaosException);
     }
 }
@@ -379,7 +377,7 @@ TEST(DesCryptTests, OutIteratorUsageEncryptTest)
 {
     {
         std::array<uint8_t, DesCrypt::BlockSize> data = { 0xe5, 0x1a, 0x9f, 0xd4, 0x19, 0xa7, 0x93, 0x44 };
-        std::array<uint8_t, 8> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
 
         std::array<uint8_t, 11> fact = {};
         // First and last 3 bytes should be untouched.
@@ -394,7 +392,7 @@ TEST(DesCryptTests, OutIteratorUsageEncryptTest)
 
     {
         std::array<uint8_t, DesCrypt::BlockSize + 2> data = { 0xe5, 0x1a, 0x9f, 0xd4, 0x19, 0xa7, 0x93, 0x44, 0x44, 0x44  };
-        std::array<uint8_t, 8> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
 
         std::array<uint8_t, 12> fact = {};
         // First and last 4 bytes should be untouched.
@@ -409,7 +407,7 @@ TEST(DesCryptTests, OutIteratorUsageEncryptTest)
 
     {
         std::array<uint8_t, DesCrypt::BlockSize + 2> data = { 0xe5, 0x1a, 0x9f, 0xd4, 0x19, 0xa7, 0x93, 0x44, 0x44, 0x44  };
-        std::array<uint8_t, 8> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
 
         std::array<uint8_t, 12> fact = {};
         std::array<uint8_t, 12> expected = {};
@@ -426,7 +424,7 @@ TEST(DesCryptTests, OutIteratorUsageDecryptTest)
 {
     {
         std::array<uint8_t, DesCrypt::BlockSize> data = { 0xe5, 0x1a, 0x9f, 0xd4, 0x19, 0xa7, 0x93, 0x44 };
-        std::array<uint8_t, 8> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
 
         std::array<uint8_t, 11> fact = {};
         // First and last 3 bytes should be untouched.
@@ -441,7 +439,7 @@ TEST(DesCryptTests, OutIteratorUsageDecryptTest)
 
     {
         std::array<uint8_t, DesCrypt::BlockSize + 2> data = { 0xe5, 0x1a, 0x9f, 0xd4, 0x19, 0xa7, 0x93, 0x44, 0x44, 0x44  };
-        std::array<uint8_t, 8> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
 
         std::array<uint8_t, 12> fact = {};
         // First and last 4 bytes should be untouched.
@@ -456,7 +454,7 @@ TEST(DesCryptTests, OutIteratorUsageDecryptTest)
 
     {
         std::array<uint8_t, DesCrypt::BlockSize + 2> data = { 0xe5, 0x1a, 0x9f, 0xd4, 0x19, 0xa7, 0x93, 0x44, 0x44, 0x44  };
-        std::array<uint8_t, 8> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
+        std::array<uint8_t, DesCrypt::KeySize> key = { 0xda, 0xec, 0x68, 0xae, 0x83, 0xe0, 0x1e, 0xab };
 
         std::array<uint8_t, 12> fact = {};
         std::array<uint8_t, 12> expected = {};
@@ -482,7 +480,7 @@ static std::vector<uint8_t> EncryptThroughBase(const Encryptor<Impl> & enc,
 
 TEST(DesCryptTests, EncryptThroughBaseTest)
 {
-    std::array<uint8_t, 8> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
+    std::array<uint8_t, DesCrypt::KeySize> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
 
     std::vector<uint8_t> data = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
     std::vector<uint8_t> expected = { 0x85, 0xe8, 0x13, 0x54, 0x0f, 0x0a, 0xb4, 0x05 };
@@ -501,7 +499,7 @@ static uint64_t EncryptUInt64BlockThroughBase(const Encryptor<Impl> & enc, uint6
 
 TEST(DesCryptTests, EncryptUInt64BlockThroughBaseTest)
 {
-    std::array<uint8_t, 8> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
+    std::array<uint8_t, DesCrypt::KeySize> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
 
     uint64_t data = 0x0123456789abcdef;
     uint64_t expected = 0x85e813540f0ab405;
@@ -525,7 +523,7 @@ static std::vector<uint8_t> DecryptThroughBase(const Decryptor<Impl> & dec,
 
 TEST(DesCryptTests, DecryptThroughBaseTest)
 {
-    std::array<uint8_t, 8> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
+    std::array<uint8_t, DesCrypt::KeySize> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
 
     std::vector<uint8_t> data = { 0x85, 0xe8, 0x13, 0x54, 0x0f, 0x0a, 0xb4, 0x05 };
     std::vector<uint8_t> expected = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };
@@ -544,7 +542,7 @@ static uint64_t DecryptUInt64BlockThroughBase(const Decryptor<Impl> & dec, uint6
 
 TEST(DesCryptTests, DecryptUInt64BlockThroughBaseTest)
 {
-    std::array<uint8_t, 8> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
+    std::array<uint8_t, DesCrypt::KeySize> key = { 0x13, 0x34, 0x57, 0x79, 0x9b, 0xbc, 0xdf, 0xf1 };
 
     uint64_t data = 0x85e813540f0ab405;
     uint64_t expected = 0x0123456789abcdef;

ChaosTests/Mac/HmacTests.cpp

@@ -99,8 +99,7 @@ TEST(HmacTests, LongKeyTest)
 
 TEST(HmacTests, UninitializedHmacTest)
 {
-    std::array<uint8_t, 10> in;
+    std::array<uint8_t, 10> in = {};
-    in.fill(0);
 
     {
         Hmac<Md5Hasher> hmac;

ChaosTests/Service/ChaosExceptionTests.cpp

@@ -0,0 +1,32 @@
+#include <gtest/gtest.h>
+#include <string>
+
+#include "Service/ChaosException.hpp"
+
+using namespace Chaos::Service;
+
+TEST(ChaosExceptionTests, RvalueRefCtorTest)
+{
+    try
+    {
+        throw ChaosException("everything's alright :D");
+    }
+    catch (const ChaosException & ex)
+    {
+        ASSERT_EQ("everything's alright :D", ex.GetMessage());
+    }
+}
+
+TEST(ChaosExceptionTests, ConstLvalueRefCtorTest)
+{
+    const std::string message = "everything's alright :D";
+
+    try
+    {
+        throw ChaosException(message);
+    }
+    catch (const ChaosException & ex)
+    {
+        ASSERT_EQ("everything's alright :D", ex.GetMessage());
+    }
+}