Merge pull request #172 from michael-loki/aligned_array

Convert llarp::AlignedBuffer to be backed by std::array

CMakeLists.txt

@@ -600,25 +600,25 @@ set(DNS_SRC
 )
 
 set(TEST_SRC
-  test/main.cpp
-  test/alignedbuffer_unittest.cpp
   test/base32_unittest.cpp
   test/dht_unittest.cpp
   test/encrypted_frame_unittest.cpp
   test/exit_unittest.cpp
   test/hiddenservice_unittest.cpp
-  test/traffic_transfer_unittest.cpp
+  test/main.cpp
+  test/net_unittest.cpp
   test/obtain_exit_unittest.cpp
   test/pq_unittest.cpp
-  test/net_unittest.cpp
   test/test_dns_unit.cpp
   test/test_dnsc_unit.cpp
   test/test_dnsd_unit.cpp
   test/test_dnslib.cpp
-  test/test_llarp_queue.cpp
+  test/test_llarp_aligned.cpp
   test/test_llarp_queue_manager.cpp
+  test/test_llarp_queue.cpp
   test/test_llarp_thread_pool.cpp
   test/test_service_address.cpp
+  test/traffic_transfer_unittest.cpp
 )
 
 set(TEST_EXE testAll)

llarp/address_info.hpp

@@ -73,7 +73,7 @@ namespace llarp
       size_t
       operator()(const AddressInfo& addr) const
       {
-        return *addr.pubkey.data_l();
+        return AlignedBuffer< PUBKEYSIZE >::Hash()(addr.pubkey);
       }
     };
   };

llarp/aligned.hpp

@@ -5,50 +5,66 @@
 #include <encode.hpp>
 #include <logger.hpp>
 
+#include <array>
+#include <cstddef>
 #include <iomanip>
 #include <iostream>
+#include <memory>
+#include <numeric>
+#include <type_traits>
 
 extern "C"
 {
   extern void
   randombytes(unsigned char* const ptr, unsigned long long sz);
-  extern void
-  sodium_memzero(void* const ptr, const size_t sz);
-  extern int
-  sodium_is_zero(const unsigned char* ptr, size_t sz);
 }
 namespace llarp
 {
-  /// aligned buffer that is sz bytes long and aligns to the nears Long_t
-  template < size_t sz, bool randomize = false, typename Long_t = uint64_t >
+  /// aligned buffer that is sz bytes long and aligns to the nearest Alignment
+  template < size_t sz >
   struct AlignedBuffer
   {
+    static constexpr size_t SIZE = sz;
+
+    using Data = std::array< byte_t, SIZE >;
+
     AlignedBuffer()
     {
-      if(randomize)
-        Randomize();
-      else
-        Zero();
+      new(&val) Data;
+      Zero();
     }
 
     AlignedBuffer(const byte_t* data)
     {
+      new(&val) Data;
+      auto& b = as_array();
       for(size_t idx = 0; idx < sz; ++idx)
+      {
         b[idx] = data[idx];
+      }
+    }
+
+    AlignedBuffer(const Data& buf)
+    {
+      new(&val) Data;
+      std::copy(buf.begin(), buf.end(), as_array().begin());
     }
 
     AlignedBuffer&
     operator=(const byte_t* data)
     {
+      auto& b = as_array();
       for(size_t idx = 0; idx < sz; ++idx)
+      {
         b[idx] = data[idx];
+      }
       return *this;
     }
 
     friend std::ostream&
     operator<<(std::ostream& out, const AlignedBuffer& self)
     {
-      char tmp[(1 + sz) * 2] = {0};
+      char tmp[(sz * 2) + 1] = {0};
       return out << HexEncode(self, tmp);
     }
 
@@ -57,75 +73,72 @@ namespace llarp
     operator~() const
     {
       AlignedBuffer< sz > ret;
-      size_t idx = 0;
-      while(idx < sz / sizeof(Long_t))
-      {
-        ret.data_l()[idx] = ~data_l()[idx];
-        ++idx;
-      }
+      std::transform(as_array().begin(), as_array().end(),
+                     ret.as_array().begin(), [](byte_t a) { return ~a; });
+
       return ret;
     }
 
     bool
     operator==(const AlignedBuffer& other) const
     {
-      return memcmp(b, other.b, sz) == 0;
+      return as_array() == other.as_array();
     }
 
     bool
     operator!=(const AlignedBuffer& other) const
     {
-      return !(*this == other);
+      return as_array() != other.as_array();
     }
 
     bool
     operator<(const AlignedBuffer& other) const
     {
-      return memcmp(l, other.l, sz) < 0;
+      return as_array() < other.as_array();
     }
 
     bool
     operator>(const AlignedBuffer& other) const
     {
-      return memcmp(l, other.l, sz) > 0;
+      return as_array() > other.as_array();
     }
 
     bool
     operator<=(const AlignedBuffer& other) const
     {
-      return memcmp(l, other.l, sz) <= 0;
+      return as_array() <= other.as_array();
     }
 
     bool
     operator>=(const AlignedBuffer& other) const
     {
-      return memcmp(l, other.l, sz) >= 0;
+      return as_array() >= other.as_array();
     }
 
     AlignedBuffer
     operator^(const AlignedBuffer& other) const
     {
       AlignedBuffer< sz > ret;
-      for(size_t idx = 0; idx < sz / sizeof(Long_t); ++idx)
-        ret.l[idx] = l[idx] ^ other.l[idx];
+      std::transform(as_array().begin(), as_array().end(),
+                     other.as_array().begin(), ret.as_array().begin(),
+                     std::bit_xor< byte_t >());
       return ret;
     }
 
     AlignedBuffer&
     operator^=(const AlignedBuffer& other)
     {
-      for(size_t idx = 0; idx < sz / sizeof(Long_t); ++idx)
-        l[idx] ^= other.l[idx];
+      // Mutate in place instead.
+      // Well defined for std::transform,
+
+      for(size_t i = 0; i < as_array().size(); ++i)
+      {
+        as_array()[i] ^= other.as_array()[i];
+      }
       return *this;
     }
 
-    size_t
-    size() const
-    {
-      return sz;
-    }
-
-    size_t
+    static constexpr size_t
     size()
     {
       return sz;
@@ -134,66 +147,78 @@ namespace llarp
     void
     Fill(byte_t f)
     {
-      for(size_t idx = 0; idx < sz; ++idx)
-        b[idx] = f;
+      as_array().fill(f);
+    }
+
+    Data&
+    as_array()
+    {
+      return reinterpret_cast< Data& >(val);
+    }
+
+    const Data&
+    as_array() const
+    {
+      return reinterpret_cast< const Data& >(val);
     }
 
     bool
     IsZero() const
     {
-      return sodium_is_zero(b, sz) != 0;
+      auto notZero = [](byte_t b) { return b != 0; };
+
+      return std::find_if(as_array().begin(), as_array().end(), notZero)
+          == as_array().end();
     }
 
     void
     Zero()
     {
-      sodium_memzero(l, sz);
+      as_array().fill(0);
     }
 
     void
     Randomize()
     {
-      randombytes(b, sz);
+      randombytes(as_array().data(), SIZE);
     }
 
     byte_t*
     data()
     {
-      return b;
+      return as_array().data();
     }
 
     const byte_t*
     data() const
     {
-      return b;
-    }
-
-    Long_t*
-    data_l()
-    {
-      return l;
-    }
-
-    const Long_t*
-    data_l() const
-    {
-      return l;
+      return as_array().data();
     }
 
     operator const byte_t*() const
     {
-      return b;
+      return as_array().data();
     }
 
     operator byte_t*()
     {
-      return b;
+      return as_array().data();
+    }
+
+    operator const Data&() const
+    {
+      return as_array();
+    }
+
+    operator Data&()
+    {
+      return as_array();
     }
 
     bool
     BEncode(llarp_buffer_t* buf) const
     {
-      return bencode_write_bytestring(buf, b, sz);
+      return bencode_write_bytestring(buf, as_array().data(), sz);
     }
 
     bool
@@ -201,13 +226,15 @@ namespace llarp
     {
       llarp_buffer_t strbuf;
       if(!bencode_read_string(buf, &strbuf))
+      {
         return false;
+      }
       if(strbuf.sz != sz)
       {
         llarp::LogError("bdecode buffer size missmatch ", strbuf.sz, "!=", sz);
         return false;
       }
-      memcpy(b, strbuf.base, sz);
+      memcpy(as_array().data(), strbuf.base, sz);
       return true;
     }
 
@@ -221,17 +248,18 @@ namespace llarp
     struct Hash
     {
       size_t
-      operator()(const AlignedBuffer< sz, randomize, Long_t >& buf) const
+      operator()(const AlignedBuffer& buf) const
       {
-        return buf.l[0];
+        return std::accumulate(buf.as_array().begin(), buf.as_array().end(), 0,
+                               std::bit_xor< size_t >());
       }
     };
 
-   protected:
-    union {
-      byte_t b[sz];
-      Long_t l[(sz / sizeof(Long_t)) + (sz % sizeof(Long_t))];
-    };
+   private:
+    using AlignedStorage =
+        typename std::aligned_storage< sizeof(Data),
+                                       alignof(std::max_align_t) >::type;
+    AlignedStorage val;
   };
 
 }  // namespace llarp

llarp/dht/key.hpp

@@ -3,17 +3,24 @@
 
 #include <aligned.hpp>
 
+#include <array>
+
 namespace llarp
 {
   namespace dht
   {
     struct Key_t : public llarp::AlignedBuffer< 32 >
     {
-      Key_t(const byte_t* val) : llarp::AlignedBuffer< 32 >(val)
+      Key_t(const byte_t* buf) : llarp::AlignedBuffer< SIZE >(buf)
       {
       }
 
-      Key_t() : llarp::AlignedBuffer< 32 >()
+      Key_t(const std::array< byte_t, SIZE >& val)
+          : llarp::AlignedBuffer< SIZE >(val.data())
+      {
+      }
+
+      Key_t() : llarp::AlignedBuffer< SIZE >()
       {
       }
 
@@ -21,33 +28,34 @@ namespace llarp
       operator^(const Key_t& other) const
       {
         Key_t dist;
-        for(size_t idx = 0; idx < (size() / sizeof(l[0])); ++idx)
-          dist.l[idx] = l[idx] ^ other.l[idx];
+        std::transform(as_array().begin(), as_array().end(),
+                       other.as_array().begin(), dist.as_array().begin(),
+                       std::bit_xor< byte_t >());
         return dist;
       }
 
       bool
       operator==(const Key_t& other) const
       {
-        return memcmp(data(), other.data(), 32) == 0;
+        return memcmp(data(), other.data(), SIZE) == 0;
       }
 
       bool
       operator!=(const Key_t& other) const
       {
-        return memcmp(data(), other.data(), 32) != 0;
+        return memcmp(data(), other.data(), SIZE) != 0;
       }
 
       bool
       operator<(const Key_t& other) const
       {
-        return memcmp(data(), other.data(), 32) < 0;
+        return memcmp(data(), other.data(), SIZE) < 0;
       }
 
       bool
       operator>(const Key_t& other) const
       {
-        return memcmp(data(), other.data(), 32) > 0;
+        return memcmp(data(), other.data(), SIZE) > 0;
       }
     };
   }  // namespace dht

llarp/dns_dotlokilookup.cpp

@@ -41,7 +41,7 @@ decode_request_name(const std::string &name, llarp::AlignedBuffer< 32 > &addr,
   auto pos = name.find(".snode");
   if(pos != std::string::npos)
   {
-    if(!llarp::HexDecode(name.substr(0, pos).c_str(), serviceAddr.data(),
+    if(!llarp::HexDecode(name.substr(0, pos).c_str(), serviceAddr.data().data(),
                          serviceAddr.size()))
     {
       return false;
@@ -55,7 +55,7 @@ decode_request_name(const std::string &name, llarp::AlignedBuffer< 32 > &addr,
     {
       return false;
     }
-    addr    = serviceAddr.data();
+    addr    = serviceAddr.data().data();
     isSNode = false;
   }
   return true;

llarp/handlers/tun.cpp

@@ -211,9 +211,9 @@ namespace llarp
         }
         else if(addr.FromString(qname, ".loki"))
         {
-          if(HasAddress(addr.data()))
+          if(HasAddress(addr.data().data()))
           {
-            huint32_t ip = ObtainIPForAddr(addr.data(), false);
+            huint32_t ip = ObtainIPForAddr(addr.data().data(), false);
             msg.AddINReply(ip);
           }
           else
@@ -227,8 +227,8 @@ namespace llarp
         else if(addr.FromString(qname, ".snode"))
         {
           // TODO: add hook to EnsurePathToSNode
-          EnsurePathToSNode(addr.data());
-          huint32_t ip = ObtainIPForAddr(addr.data(), true);
+          EnsurePathToSNode(addr.data().data());
+          huint32_t ip = ObtainIPForAddr(addr.data().data(), true);
           msg.AddINReply(ip);
         }
         else
@@ -310,7 +310,7 @@ namespace llarp
     {
       if(ctx)
       {
-        huint32_t ip = ObtainIPForAddr(addr.data(), false);
+        huint32_t ip = ObtainIPForAddr(addr.data().data(), false);
         request.AddINReply(ip);
       }
       else
@@ -333,9 +333,9 @@ namespace llarp
       }
       llarp::LogInfo(Name() + " map ", addr.ToString(), " to ", ip);
 
-      m_IPToAddr[ip]          = addr.data();
-      m_AddrToIP[addr.data()] = ip;
-      m_SNodes[addr.data()]   = SNode;
+      m_IPToAddr[ip]                 = addr.data().data();
+      m_AddrToIP[addr.data().data()] = ip;
+      m_SNodes[addr.data().data()]   = SNode;
       MarkIPActiveForever(ip);
       return true;
     }

llarp/pathset.hpp

@@ -191,7 +191,7 @@ namespace llarp
         size_t
         operator()(const PathInfo_t& i) const
         {
-          return *i.first.data_l() ^ *i.second.data_l();
+          return RouterID::Hash()(i.first) ^ PathID_t::Hash()(i.second);
         }
       };
       using Mtx_t     = llarp::util::NullMutex;

llarp/router_id.hpp

@@ -7,11 +7,19 @@ namespace llarp
 {
   struct RouterID : public AlignedBuffer< 32 >
   {
-    RouterID() : AlignedBuffer< 32 >()
+    static constexpr size_t SIZE = 32;
+
+    using Data = std::array< byte_t, SIZE >;
+
+    RouterID() : AlignedBuffer< SIZE >()
     {
     }
 
-    RouterID(const byte_t* buf) : AlignedBuffer< 32 >(buf)
+    RouterID(const byte_t* buf) : AlignedBuffer< SIZE >(buf)
+    {
+    }
+
+    RouterID(const Data& data) : AlignedBuffer< SIZE >(data)
     {
     }
 
@@ -24,7 +32,7 @@ namespace llarp
     RouterID&
     operator=(const byte_t* ptr)
     {
-      memcpy(data(), ptr, 32);
+      memcpy(data(), ptr, SIZE);
       return *this;
     }
 
@@ -34,7 +42,7 @@ namespace llarp
       return out << id.ToString();
     }
 
-    using Hash = AlignedBuffer< 32 >::Hash;
+    using Hash = AlignedBuffer< SIZE >::Hash;
   };
 }  // namespace llarp
 

llarp/service/Info.hpp

@@ -121,8 +121,7 @@ namespace llarp
       }
 
       /// calculate our address
-      bool
-      CalculateAddress(byte_t* buf) const;
+      bool CalculateAddress(std::array< byte_t, 32 >& data) const;
 
       bool
       BDecode(llarp_buffer_t* buf) override

llarp/service/Intro.hpp

@@ -86,7 +86,7 @@ namespace llarp
         size_t
         operator()(const Introduction& i) const
         {
-          return *i.router.data_l() ^ *i.pathID.data_l();
+          return PubKey::Hash()(i.router) ^ PathID_t::Hash()(i.pathID);
         }
       };
     };

llarp/service/address.hpp

@@ -5,6 +5,8 @@
 #include <dht/key.hpp>
 #include <router_id.hpp>
 
+#include <functional>
+#include <numeric>
 #include <string>
 
 namespace llarp
@@ -14,6 +16,10 @@ namespace llarp
     /// Snapp/Snode Address
     struct Address
     {
+      static constexpr size_t SIZE = 32;
+
+      using Data = std::array< byte_t, SIZE >;
+
       std::string
       ToString(const char* tld = ".loki") const;
 
@@ -27,12 +33,12 @@ namespace llarp
 
       Address(const byte_t* buf)
       {
-        memcpy(b, buf, 32);
+        std::copy(buf, buf + SIZE, b.begin());
       }
 
       Address(const Address& other)
       {
-        memcpy(b, other.b, 32);
+        b = other.b;
       }
 
       byte_t& operator[](size_t idx)
@@ -48,7 +54,7 @@ namespace llarp
       bool
       BEncode(llarp_buffer_t* buf) const
       {
-        return bencode_write_bytestring(buf, b, 32);
+        return bencode_write_bytestring(buf, b.data(), SIZE);
       }
 
       bool
@@ -57,49 +63,39 @@ namespace llarp
         llarp_buffer_t strbuf;
         if(!bencode_read_string(buf, &strbuf))
           return false;
-        if(strbuf.sz != 32)
+        if(strbuf.sz != SIZE)
         {
           llarp::LogErrorTag("Address::BDecode",
                              "bdecode buffer size missmatch ", strbuf.sz,
                              "!=32");
           return false;
         }
-        memcpy(b, strbuf.base, 32);
+        std::copy(strbuf.base, strbuf.base + SIZE, b.begin());
         return true;
       }
 
-      size_t
-      size() const
+      static constexpr size_t
+      size()
       {
-        return 32;
+        return SIZE;
       }
 
       bool
       IsZero() const
       {
-        size_t sz = 4;
-        while(sz)
-        {
-          if(l[--sz])
-            return false;
-        }
-        return true;
+        return b == Data{};
       }
 
       void
       Zero()
       {
-        size_t sz = 4;
-        while(sz)
-        {
-          l[--sz] = 0;
-        }
+        b.fill(0);
       }
 
       bool
       operator<(const Address& other) const
       {
-        return memcmp(data(), other.data(), 32) < 0;
+        return data() < other.data();
       }
 
       friend std::ostream&
@@ -111,7 +107,7 @@ namespace llarp
       bool
       operator==(const Address& other) const
       {
-        return memcmp(data(), other.data(), 32) == 0;
+        return data() == other.data();
       }
 
       bool
@@ -121,11 +117,7 @@ namespace llarp
       }
 
       Address&
-      operator=(const Address& other)
-      {
-        memcpy(data(), other.data(), 32);
-        return *this;
-      }
+      operator=(const Address& other) = default;
 
       const dht::Key_t
       ToKey() const
@@ -136,41 +128,33 @@ namespace llarp
       const RouterID
       ToRouter() const
       {
-        return RouterID(data());
+        return RouterID(data().data());
       }
 
-      const byte_t*
+      const Data&
       data() const
       {
         return b;
       }
 
-      byte_t*
+      Data&
       data()
       {
         return b;
       }
 
-      const uint64_t*
-      data_l() const
-      {
-        return l;
-      }
-
       struct Hash
       {
         size_t
         operator()(const Address& buf) const
         {
-          return *buf.data_l();
+          return std::accumulate(buf.data().begin(), buf.data().end(), 0,
+                                 std::bit_xor< size_t >());
         }
       };
 
      private:
-      union {
-        byte_t b[32];
-        uint64_t l[4];
-      };
+      Data b;
     };
 
   }  // namespace service

llarp/service/endpoint.cpp

@@ -538,7 +538,7 @@ namespace llarp
     Endpoint::PublishIntroSet(llarp::Router* r)
     {
       // publish via near router
-      RouterID location = m_Identity.pub.Addr().data();
+      RouterID location = m_Identity.pub.Addr().data().data();
       auto path         = GetEstablishedPathClosestTo(location);
       return path && PublishIntroSetVia(r, path);
     }
@@ -827,9 +827,10 @@ namespace llarp
       if(msg->proto == eProtocolTraffic)
       {
         auto buf = llarp::Buffer(msg->payload);
-        return HandleWriteIPPacket(buf,
-                                   std::bind(&Endpoint::ObtainIPForAddr, this,
-                                             msg->sender.Addr().data(), false));
+        return HandleWriteIPPacket(
+            buf,
+            std::bind(&Endpoint::ObtainIPForAddr, this,
+                      msg->sender.Addr().data().data(), false));
       }
       else if(msg->proto == eProtocolText)
       {

llarp/service/info.cpp

@@ -56,15 +56,14 @@ namespace llarp
       return m_CachedAddr.ToString();
     }
 
-    bool
-    ServiceInfo::CalculateAddress(byte_t* addr) const
+    bool ServiceInfo::CalculateAddress(std::array< byte_t, 32 >& data) const
     {
       byte_t tmp[256] = {0};
       auto buf        = llarp::StackBuffer< decltype(tmp) >(tmp);
       if(!BEncode(&buf))
         return false;
-      return crypto_generichash_blake2b(addr, 32, buf.base, buf.cur - buf.base,
-                                        nullptr, 0)
+      return crypto_generichash_blake2b(data.data(), data.size(), buf.base,
+                                        buf.cur - buf.base, nullptr, 0)
           != -1;
     }
 

llarp/service/tag.hpp

@@ -54,14 +54,7 @@ namespace llarp
         return ToString().empty();
       }
 
-      struct Hash
-      {
-        std::size_t
-        operator()(const Tag& t) const
-        {
-          return *t.data_l();
-        }
-      };
+      using Hash = AlignedBuffer< SIZE >::Hash;
     };
   }  // namespace service
 }  // namespace llarp

test/alignedbuffer_unittest.cpp

@@ -1,33 +0,0 @@
-#include <gtest/gtest.h>
-
-#include <crypto.hpp>
-
-using Buffer_t = llarp::AlignedBuffer< 32 >;
-using Map_t    = std::unordered_map< Buffer_t, int, Buffer_t::Hash >;
-
-struct AlignedBufferTest : public ::testing::Test
-{
-  AlignedBufferTest() : crypto(llarp::Crypto::sodium{})
-  {
-  }
-
-  llarp::Crypto crypto;
-};
-
-TEST_F(AlignedBufferTest, TestHash)
-{
-  Buffer_t k, other_k;
-  k.Randomize();
-  other_k.Randomize();
-  Map_t m;
-  ASSERT_TRUE(m.empty());
-  ASSERT_TRUE(m.emplace(k, 1).second);
-  ASSERT_TRUE(m.find(k) != m.end());
-  ASSERT_TRUE(m[k] == 1);
-  ASSERT_FALSE(m.find(other_k) != m.end());
-  ASSERT_TRUE(m.size() == 1);
-  Buffer_t k_copy = k;
-  ASSERT_FALSE(m.emplace(k_copy, 2).second);
-  ASSERT_FALSE(m[k_copy] == 2);
-  ASSERT_TRUE(m[k_copy] == 1);
-};

test/test_llarp_aligned.cpp

@@ -0,0 +1,232 @@
+#include <gtest/gtest.h>
+
+#include <aligned.hpp>
+#include <crypto.hpp>
+
+#include <iostream>
+#include <sstream>
+#include <type_traits>
+#include <unordered_map>
+
+using TestSizes =
+    ::testing::Types< std::integral_constant< std::size_t, 2 >,
+                      std::integral_constant< std::size_t, 3 >,
+                      std::integral_constant< std::size_t, 4 >,
+                      std::integral_constant< std::size_t, 8 >,
+                      std::integral_constant< std::size_t, 16 >,
+                      std::integral_constant< std::size_t, 32 >,
+                      std::integral_constant< std::size_t, 64 >,
+                      std::integral_constant< std::size_t, 1024 > >;
+
+template < typename T >
+struct AlignedBufferTest : public ::testing::Test
+{
+  AlignedBufferTest() : crypto(llarp::Crypto::sodium{})
+  {
+  }
+  llarp::Crypto crypto;
+};
+
+TYPED_TEST_CASE(AlignedBufferTest, TestSizes);
+
+TYPED_TEST(AlignedBufferTest, Constructor)
+{
+  using Buffer = llarp::AlignedBuffer< TypeParam::value >;
+
+  Buffer b;
+  EXPECT_TRUE(b.IsZero());
+  EXPECT_EQ(b.size(), TypeParam::value);
+}
+
+TYPED_TEST(AlignedBufferTest, CopyConstructor)
+{
+  using Buffer = llarp::AlignedBuffer< TypeParam::value >;
+
+  Buffer b;
+  EXPECT_TRUE(b.IsZero());
+
+  Buffer c = b;
+  EXPECT_TRUE(c.IsZero());
+
+  c.Fill(1);
+  EXPECT_FALSE(c.IsZero());
+
+  Buffer d = c;
+  EXPECT_FALSE(d.IsZero());
+}
+
+TYPED_TEST(AlignedBufferTest, AltConstructors)
+{
+  using Buffer = llarp::AlignedBuffer< TypeParam::value >;
+
+  Buffer b;
+  EXPECT_TRUE(b.IsZero());
+  b.Fill(2);
+
+  Buffer c(b.as_array());
+  EXPECT_FALSE(c.IsZero());
+
+  Buffer d(c.data());
+  EXPECT_FALSE(d.IsZero());
+}
+
+TYPED_TEST(AlignedBufferTest, Assignment)
+{
+  using Buffer = llarp::AlignedBuffer< TypeParam::value >;
+
+  Buffer b;
+  EXPECT_TRUE(b.IsZero());
+
+  Buffer c;
+  c = b;
+  EXPECT_TRUE(c.IsZero());
+
+  c.Fill(1);
+  EXPECT_FALSE(c.IsZero());
+
+  Buffer d;
+  d = c;
+  EXPECT_FALSE(d.IsZero());
+}
+
+TYPED_TEST(AlignedBufferTest, StreamOut)
+{
+  using Buffer = llarp::AlignedBuffer< TypeParam::value >;
+
+  Buffer b;
+  EXPECT_TRUE(b.IsZero());
+
+  std::stringstream stream;
+
+  stream << b;
+
+  EXPECT_EQ(stream.str(), std::string(TypeParam::value * 2, '0'));
+
+  stream.str("");
+
+  b.Fill(255);
+  stream << b;
+
+  EXPECT_EQ(stream.str(), std::string(TypeParam::value * 2, 'f'));
+}
+
+TYPED_TEST(AlignedBufferTest, BitwiseNot)
+{
+  using Buffer = llarp::AlignedBuffer< TypeParam::value >;
+
+  Buffer b;
+  EXPECT_TRUE(b.IsZero());
+
+  Buffer c = ~b;
+  EXPECT_FALSE(c.IsZero());
+
+  for(auto val : c.as_array())
+  {
+    EXPECT_EQ(255, val);
+  }
+
+  Buffer d = ~c;
+  EXPECT_TRUE(d.IsZero());
+}
+
+TYPED_TEST(AlignedBufferTest, Operators)
+{
+  using Buffer = llarp::AlignedBuffer< TypeParam::value >;
+
+  Buffer b;
+  EXPECT_TRUE(b.IsZero());
+
+  Buffer c = b;
+  EXPECT_EQ(b, c);
+  EXPECT_GE(b, c);
+  EXPECT_LE(b, c);
+  EXPECT_GE(c, b);
+  EXPECT_LE(c, b);
+
+  c.Fill(1);
+  EXPECT_NE(b, c);
+  EXPECT_LT(b, c);
+  EXPECT_GT(c, b);
+}
+
+TYPED_TEST(AlignedBufferTest, Xor)
+{
+  using Buffer = llarp::AlignedBuffer< TypeParam::value >;
+
+  Buffer b;
+  Buffer c;
+  b.Fill(255);
+  c.Fill(255);
+  EXPECT_FALSE(b.IsZero());
+  EXPECT_FALSE(c.IsZero());
+
+  Buffer d = b ^ c;
+  // 1 ^ 1 = 0
+  EXPECT_TRUE(d.IsZero());
+  // Verify unchanged
+  EXPECT_FALSE(b.IsZero());
+  EXPECT_FALSE(c.IsZero());
+
+  Buffer e, f;
+  e.Fill(255);
+  Buffer g = e ^ f;
+  // 1 ^ 0 = 1
+  EXPECT_FALSE(g.IsZero());
+
+  Buffer h, i;
+  i.Fill(255);
+  Buffer j = h ^ i;
+  // 0 ^ 1 = 1
+  EXPECT_FALSE(j.IsZero());
+}
+
+TYPED_TEST(AlignedBufferTest, XorAssign)
+{
+  using Buffer = llarp::AlignedBuffer< TypeParam::value >;
+
+  Buffer b, c;
+  b.Fill(255);
+  c.Fill(255);
+  EXPECT_FALSE(b.IsZero());
+  EXPECT_FALSE(c.IsZero());
+
+  b ^= c;
+  EXPECT_TRUE(b.IsZero());
+}
+
+TYPED_TEST(AlignedBufferTest, Zero)
+{
+  using Buffer = llarp::AlignedBuffer< TypeParam::value >;
+
+  Buffer b;
+  EXPECT_TRUE(b.IsZero());
+
+  b.Fill(127);
+  EXPECT_FALSE(b.IsZero());
+
+  b.Zero();
+  EXPECT_TRUE(b.IsZero());
+}
+
+TYPED_TEST(AlignedBufferTest, TestHash)
+{
+  using Buffer = llarp::AlignedBuffer< TypeParam::value >;
+  using Map_t  = std::unordered_map< Buffer, int, typename Buffer::Hash >;
+
+  Buffer k, other_k;
+  k.Randomize();
+  other_k.Randomize();
+  Map_t m;
+  EXPECT_TRUE(m.empty());
+  EXPECT_TRUE(m.emplace(k, 1).second);
+  EXPECT_TRUE(m.find(k) != m.end());
+  EXPECT_TRUE(m[k] == 1);
+  EXPECT_FALSE(m.find(other_k) != m.end());
+  EXPECT_TRUE(m.size() == 1);
+  Buffer k_copy = k;
+  EXPECT_FALSE(m.emplace(k_copy, 2).second);
+  EXPECT_FALSE(m[k_copy] == 2);
+  EXPECT_TRUE(m[k_copy] == 1);
+};
+
+// TEST_P(Copy, )