Apply clang-format to folly/**/*Address*.*

Summary: [Folly] Apply `clang-format` to `folly/**/*Address*.*`.

Reviewed By: Orvid

Differential Revision: D5581523

fbshipit-source-id: 97b5270e43e279e7deb9606524d5fee844a50649

folly/IPAddress.cpp

@@ -69,7 +69,8 @@ IPAddressV6 IPAddress::createIPv6(const IPAddress& addr) {
 }
 
 // public static
-CIDRNetwork IPAddress::createNetwork(StringPiece ipSlashCidr,
+CIDRNetwork IPAddress::createNetwork(
+    StringPiece ipSlashCidr,
     int defaultCidr, /* = -1 */
     bool applyMask /* = true */) {
   if (defaultCidr > std::numeric_limits<uint8_t>::max()) {
@@ -133,17 +134,10 @@ IPAddress IPAddress::fromLongHBO(uint32_t src) {
 }
 
 // default constructor
-IPAddress::IPAddress()
-  : addr_()
-  , family_(AF_UNSPEC)
-{
-}
+IPAddress::IPAddress() : addr_(), family_(AF_UNSPEC) {}
 
 // public string constructor
-IPAddress::IPAddress(StringPiece addr)
-  : addr_()
-  , family_(AF_UNSPEC)
-{
+IPAddress::IPAddress(StringPiece addr) : addr_(), family_(AF_UNSPEC) {
   string ip = addr.str(); // inet_pton() needs NUL-terminated string
   auto throwFormatException = [&](const string& msg) {
     throw IPAddressFormatException(sformat("Invalid IP '{}': {}", ip, msg));
@@ -186,22 +180,19 @@ IPAddress::IPAddress(StringPiece addr)
 }
 
 // public sockaddr constructor
-IPAddress::IPAddress(const sockaddr* addr)
-  : addr_()
-  , family_(AF_UNSPEC)
-{
+IPAddress::IPAddress(const sockaddr* addr) : addr_(), family_(AF_UNSPEC) {
   if (addr == nullptr) {
     throw IPAddressFormatException("sockaddr == nullptr");
   }
   family_ = addr->sa_family;
   switch (addr->sa_family) {
     case AF_INET: {
-      const sockaddr_in *v4addr = reinterpret_cast<const sockaddr_in*>(addr);
+      const sockaddr_in* v4addr = reinterpret_cast<const sockaddr_in*>(addr);
       addr_.ipV4Addr = IPAddressV4(v4addr->sin_addr);
       break;
     }
     case AF_INET6: {
-      const sockaddr_in6 *v6addr = reinterpret_cast<const sockaddr_in6*>(addr);
+      const sockaddr_in6* v6addr = reinterpret_cast<const sockaddr_in6*>(addr);
       addr_.ipV6Addr = IPAddressV6(*v6addr);
       break;
     }
@@ -212,31 +203,19 @@ IPAddress::IPAddress(const sockaddr* addr)
 
 // public ipv4 constructor
 IPAddress::IPAddress(const IPAddressV4 ipV4Addr)
-  : addr_(ipV4Addr)
-  , family_(AF_INET)
-{
-}
+    : addr_(ipV4Addr), family_(AF_INET) {}
 
 // public ipv4 constructor
 IPAddress::IPAddress(const in_addr ipV4Addr)
-  : addr_(IPAddressV4(ipV4Addr))
-  , family_(AF_INET)
-{
-}
+    : addr_(IPAddressV4(ipV4Addr)), family_(AF_INET) {}
 
 // public ipv6 constructor
 IPAddress::IPAddress(const IPAddressV6& ipV6Addr)
-  : addr_(ipV6Addr)
-  , family_(AF_INET6)
-{
-}
+    : addr_(ipV6Addr), family_(AF_INET6) {}
 
 // public ipv6 constructor
 IPAddress::IPAddress(const in6_addr& ipV6Addr)
-  : addr_(IPAddressV6(ipV6Addr))
-  , family_(AF_INET6)
-{
-}
+    : addr_(IPAddressV6(ipV6Addr)), family_(AF_INET6) {}
 
 // Assign from V4 address
 IPAddress& IPAddress::operator=(const IPAddressV4& ipv4_addr) {
@@ -286,8 +265,8 @@ bool IPAddress::inSubnet(const IPAddress& subnet, uint8_t cidr) const {
 }
 
 // public
-bool IPAddress::inSubnetWithMask(const IPAddress& subnet,
-                                 ByteRange mask) const {
+bool IPAddress::inSubnetWithMask(const IPAddress& subnet, ByteRange mask)
+    const {
   auto mkByteArray4 = [&]() -> ByteArray4 {
     ByteArray4 ba{{0}};
     std::memcpy(ba.data(), mask.begin(), std::min<size_t>(mask.size(), 4));
@@ -392,8 +371,9 @@ bool operator<(const IPAddress& addr1, const IPAddress& addr2) {
   return false;
 }
 
-CIDRNetwork
-IPAddress::longestCommonPrefix(const CIDRNetwork& one, const CIDRNetwork& two) {
+CIDRNetwork IPAddress::longestCommonPrefix(
+    const CIDRNetwork& one,
+    const CIDRNetwork& two) {
   if (one.first.family() != two.first.family()) {
     throw std::invalid_argument(sformat(
         "Can't compute longest common prefix between addresses of different"
@@ -403,13 +383,11 @@ IPAddress::longestCommonPrefix(const CIDRNetwork& one, const CIDRNetwork& two) {
   }
   if (one.first.isV4()) {
     auto prefix = IPAddressV4::longestCommonPrefix(
-      {one.first.asV4(), one.second},
-      {two.first.asV4(), two.second});
+        {one.first.asV4(), one.second}, {two.first.asV4(), two.second});
     return {IPAddress(prefix.first), prefix.second};
   } else if (one.first.isV6()) {
     auto prefix = IPAddressV6::longestCommonPrefix(
-      {one.first.asV6(), one.second},
-      {two.first.asV6(), two.second});
+        {one.first.asV6(), one.second}, {two.first.asV6(), two.second});
     return {IPAddress(prefix.first), prefix.second};
   } else {
     throw std::invalid_argument("Unknown address family");

folly/IPAddress.h

@@ -95,7 +95,9 @@ class IPAddress {
    * @return pair with IPAddress network and uint8_t mask
    */
   static CIDRNetwork createNetwork(
-    StringPiece ipSlashCidr, int defaultCidr = -1, bool mask = true);
+      StringPiece ipSlashCidr,
+      int defaultCidr = -1,
+      bool mask = true);
 
   /**
    * Return a string representation of a CIDR block created with createNetwork.
@@ -122,7 +124,8 @@ class IPAddress {
 
   // Given 2 IPAddress,mask pairs extract the longest common IPAddress,
   // mask pair
-  static CIDRNetwork longestCommonPrefix(const CIDRNetwork& one,
+  static CIDRNetwork longestCommonPrefix(
+      const CIDRNetwork& one,
       const CIDRNetwork& two);
 
   /**
@@ -188,10 +191,12 @@ class IPAddress {
   }
 
   // Return sa_family_t of IPAddress
-  sa_family_t family() const { return family_; }
+  sa_family_t family() const {
+    return family_;
+  }
 
   // Populate sockaddr_storage with an appropriate value
-  int toSockaddrStorage(sockaddr_storage *dest, uint16_t port = 0) const {
+  int toSockaddrStorage(sockaddr_storage* dest, uint16_t port = 0) const {
     if (dest == nullptr) {
       throw IPAddressFormatException("dest must not be null");
     }
@@ -199,7 +204,7 @@ class IPAddress {
     dest->ss_family = family();
 
     if (isV4()) {
-      sockaddr_in *sin = reinterpret_cast<sockaddr_in*>(dest);
+      sockaddr_in* sin = reinterpret_cast<sockaddr_in*>(dest);
       sin->sin_addr = asV4().toAddr();
       sin->sin_port = port;
 #if defined(__APPLE__)
@@ -207,7 +212,7 @@ class IPAddress {
 #endif
       return sizeof(*sin);
     } else if (isV6()) {
-      sockaddr_in6 *sin = reinterpret_cast<sockaddr_in6*>(dest);
+      sockaddr_in6* sin = reinterpret_cast<sockaddr_in6*>(dest);
       sin->sin6_addr = asV6().toAddr();
       sin->sin6_port = port;
       sin->sin6_scope_id = asV6().getScopeId();
@@ -260,16 +265,24 @@ class IPAddress {
   }
 
   // @return true if address is uninitialized
-  bool empty() const { return (family_ == AF_UNSPEC); }
+  bool empty() const {
+    return (family_ == AF_UNSPEC);
+  }
 
   // @return true if address is initialized
-  explicit operator bool() const { return !empty(); }
+  explicit operator bool() const {
+    return !empty();
+  }
 
   // @return true if this is an IPAddressV4 instance
-  bool isV4() const { return (family_ == AF_INET); }
+  bool isV4() const {
+    return (family_ == AF_INET);
+  }
 
   // @return true if this is an IPAddressV6 instance
-  bool isV6() const { return (family_ == AF_INET6); }
+  bool isV6() const {
+    return (family_ == AF_INET6);
+  }
 
   // @return true if this address is all zeros
   bool isZero() const {
@@ -284,17 +297,17 @@ class IPAddress {
   size_t byteCount() const {
     return bitCount() / 8;
   }
-  //get nth most significant bit - 0 indexed
+  // get nth most significant bit - 0 indexed
   bool getNthMSBit(size_t bitIndex) const {
     return detail::getNthMSBitImpl(*this, bitIndex, family());
   }
-  //get nth most significant byte - 0 indexed
+  // get nth most significant byte - 0 indexed
   uint8_t getNthMSByte(size_t byteIndex) const;
-  //get nth bit - 0 indexed
+  // get nth bit - 0 indexed
   bool getNthLSBit(size_t bitIndex) const {
     return getNthMSBit(bitCount() - bitIndex - 1);
   }
-  //get nth byte - 0 indexed
+  // get nth byte - 0 indexed
   uint8_t getNthLSByte(size_t byteIndex) const {
     return getNthMSByte(byteCount() - byteIndex - 1);
   }
@@ -408,8 +421,8 @@ class IPAddress {
     IPAddressV46() {
       std::memset(this, 0, sizeof(IPAddressV46));
     }
-    explicit IPAddressV46(const IPAddressV4& addr): ipV4Addr(addr) {}
-    explicit IPAddressV46(const IPAddressV6& addr): ipV6Addr(addr) {}
+    explicit IPAddressV46(const IPAddressV4& addr) : ipV4Addr(addr) {}
+    explicit IPAddressV46(const IPAddressV6& addr) : ipV6Addr(addr) {}
   } IPAddressV46;
   IPAddressV46 addr_;
   sa_family_t family_;

folly/IPAddressV4.cpp

@@ -29,7 +29,6 @@ using std::string;
 
 namespace folly {
 
-
 // free functions
 size_t hash_value(const IPAddressV4& addr) {
   return addr.hash();
@@ -85,19 +84,13 @@ uint32_t IPAddressV4::toLongHBO(StringPiece ip) {
 }
 
 // public default constructor
-IPAddressV4::IPAddressV4() {
-}
+IPAddressV4::IPAddressV4() {}
 
 // ByteArray4 constructor
-IPAddressV4::IPAddressV4(const ByteArray4& src)
-  : addr_(src)
-{
-}
+IPAddressV4::IPAddressV4(const ByteArray4& src) : addr_(src) {}
 
 // public string constructor
-IPAddressV4::IPAddressV4(StringPiece addr)
-  : addr_()
-{
+IPAddressV4::IPAddressV4(StringPiece addr) : addr_() {
   auto ip = addr.str();
   if (inet_pton(AF_INET, ip.c_str(), &addr_.inAddr_) != 1) {
     throw IPAddressFormatException(sformat("Invalid IPv4 address '{}'", addr));
@@ -105,10 +98,7 @@ IPAddressV4::IPAddressV4(StringPiece addr)
 }
 
 // in_addr constructor
-IPAddressV4::IPAddressV4(const in_addr src)
-  : addr_(src)
-{
-}
+IPAddressV4::IPAddressV4(const in_addr src) : addr_(src) {}
 
 // public
 void IPAddressV4::setFromBinary(ByteRange bytes) {
@@ -172,11 +162,11 @@ bool IPAddressV4::inSubnet(StringPiece cidrNetwork) const {
 }
 
 // public
-bool IPAddressV4::inSubnetWithMask(const IPAddressV4& subnet,
+bool IPAddressV4::inSubnetWithMask(
+    const IPAddressV4& subnet,
     const ByteArray4 cidrMask) const {
-  const ByteArray4 mask = detail::Bytes::mask(toByteArray(), cidrMask);
-  const ByteArray4 subMask = detail::Bytes::mask(subnet.toByteArray(),
-                                                 cidrMask);
+  const auto mask = detail::Bytes::mask(toByteArray(), cidrMask);
+  const auto subMask = detail::Bytes::mask(subnet.toByteArray(), cidrMask);
   return (mask == subMask);
 }
 
@@ -196,24 +186,26 @@ bool IPAddressV4::isLinkLocal() const {
 bool IPAddressV4::isNonroutable() const {
   auto ip = toLongHBO();
   return isPrivate() ||
-      (ip <= 0x00FFFFFF)                     || // 0.0.0.0-0.255.255.255
+      (/* align */ true && ip <= 0x00FFFFFF) || // 0.0.0.0-0.255.255.255
       (ip >= 0xC0000000 && ip <= 0xC00000FF) || // 192.0.0.0-192.0.0.255
       (ip >= 0xC0000200 && ip <= 0xC00002FF) || // 192.0.2.0-192.0.2.255
       (ip >= 0xC6120000 && ip <= 0xC613FFFF) || // 198.18.0.0-198.19.255.255
       (ip >= 0xC6336400 && ip <= 0xC63364FF) || // 198.51.100.0-198.51.100.255
       (ip >= 0xCB007100 && ip <= 0xCB0071FF) || // 203.0.113.0-203.0.113.255
-      (ip >= 0xE0000000 && ip <= 0xFFFFFFFF);   // 224.0.0.0-255.255.255.255
+      (ip >= 0xE0000000 && ip <= 0xFFFFFFFF) || // 224.0.0.0-255.255.255.255
+      false;
 }
 
 // public
 bool IPAddressV4::isPrivate() const {
   auto ip = toLongHBO();
-  return
+  return // some ranges below
       (ip >= 0x0A000000 && ip <= 0x0AFFFFFF) || // 10.0.0.0-10.255.255.255
       (ip >= 0x7F000000 && ip <= 0x7FFFFFFF) || // 127.0.0.0-127.255.255.255
       (ip >= 0xA9FE0000 && ip <= 0xA9FEFFFF) || // 169.254.0.0-169.254.255.255
       (ip >= 0xAC100000 && ip <= 0xAC1FFFFF) || // 172.16.0.0-172.31.255.255
-      (ip >= 0xC0A80000 && ip <= 0xC0A8FFFF);   // 192.168.0.0-192.168.255.255
+      (ip >= 0xC0A80000 && ip <= 0xC0A8FFFF) || // 192.168.0.0-192.168.255.255
+      false;
 }
 
 // public

folly/IPAddressV4.h

@@ -80,7 +80,7 @@ class IPAddressV4 {
    * Returns the address as a Range.
    */
   ByteRange toBinary() const {
-    return ByteRange((const unsigned char *) &addr_.inAddr_.s_addr, 4);
+    return ByteRange((const unsigned char*)&addr_.inAddr_.s_addr, 4);
   }
 
   /**
@@ -140,7 +140,9 @@ class IPAddressV4 {
    * @see IPAddress#bitCount
    * @returns 32
    */
-  static size_t bitCount() { return 32; }
+  static size_t bitCount() {
+    return 32;
+  }
 
   /**
    * @See IPAddress#toJson
@@ -197,7 +199,9 @@ class IPAddressV4 {
   std::string toInverseArpaName() const;
 
   // return underlying in_addr structure
-  in_addr toAddr() const { return addr_.inAddr_; }
+  in_addr toAddr() const {
+    return addr_.inAddr_;
+  }
 
   sockaddr_in toSockAddr() const {
     sockaddr_in addr;
@@ -214,13 +218,17 @@ class IPAddressV4 {
   }
 
   // @see IPAddress#toFullyQualified
-  std::string toFullyQualified() const { return str(); }
+  std::string toFullyQualified() const {
+    return str();
+  }
 
   // @see IPAddress#toFullyQualifiedAppend
   void toFullyQualifiedAppend(std::string& out) const;
 
   // @see IPAddress#version
-  uint8_t version() const { return 4; }
+  uint8_t version() const {
+    return 4;
+  }
 
   /**
    * Return the mask associated with the given number of bits.
@@ -238,35 +246,40 @@ class IPAddressV4 {
       const CIDRNetworkV4& one,
       const CIDRNetworkV4& two);
   // Number of bytes in the address representation.
-  static size_t byteCount() { return 4; }
-  //get nth most significant bit - 0 indexed
+  static size_t byteCount() {
+    return 4;
+  }
+  // get nth most significant bit - 0 indexed
   bool getNthMSBit(size_t bitIndex) const {
     return detail::getNthMSBitImpl(*this, bitIndex, AF_INET);
   }
-  //get nth most significant byte - 0 indexed
+  // get nth most significant byte - 0 indexed
   uint8_t getNthMSByte(size_t byteIndex) const;
-  //get nth bit - 0 indexed
+  // get nth bit - 0 indexed
   bool getNthLSBit(size_t bitIndex) const {
     return getNthMSBit(bitCount() - bitIndex - 1);
   }
-  //get nth byte - 0 indexed
+  // get nth byte - 0 indexed
   uint8_t getNthLSByte(size_t byteIndex) const {
     return getNthMSByte(byteCount() - byteIndex - 1);
   }
 
-  const unsigned char* bytes() const { return addr_.bytes_.data(); }
+  const unsigned char* bytes() const {
+    return addr_.bytes_.data();
+  }
 
  private:
   union AddressStorage {
-    static_assert(sizeof(in_addr) == sizeof(ByteArray4),
+    static_assert(
+        sizeof(in_addr) == sizeof(ByteArray4),
         "size of in_addr and ByteArray4 are different");
     in_addr inAddr_;
     ByteArray4 bytes_;
     AddressStorage() {
       std::memset(this, 0, sizeof(AddressStorage));
     }
-    explicit AddressStorage(const ByteArray4 bytes): bytes_(bytes) {}
-    explicit AddressStorage(const in_addr addr): inAddr_(addr) {}
+    explicit AddressStorage(const ByteArray4 bytes) : bytes_(bytes) {}
+    explicit AddressStorage(const in_addr addr) : inAddr_(addr) {}
   } addr_;
 
   /**

folly/IPAddressV6.cpp

@@ -77,8 +77,7 @@ bool IPAddressV6::validate(StringPiece ip) {
 }
 
 // public default constructor
-IPAddressV6::IPAddressV6() {
-}
+IPAddressV6::IPAddressV6() {}
 
 // public string constructor
 IPAddressV6::IPAddressV6(StringPiece addr) {
@@ -110,28 +109,17 @@ IPAddressV6::IPAddressV6(StringPiece addr) {
 }
 
 // in6_addr constructor
-IPAddressV6::IPAddressV6(const in6_addr& src)
-  : addr_(src)
-{
-}
+IPAddressV6::IPAddressV6(const in6_addr& src) : addr_(src) {}
 
 // sockaddr_in6 constructor
 IPAddressV6::IPAddressV6(const sockaddr_in6& src)
-  : addr_(src.sin6_addr)
-  , scope_(uint16_t(src.sin6_scope_id))
-{
-}
+    : addr_(src.sin6_addr), scope_(uint16_t(src.sin6_scope_id)) {}
 
 // ByteArray16 constructor
-IPAddressV6::IPAddressV6(const ByteArray16& src)
-  : addr_(src)
-{
-}
+IPAddressV6::IPAddressV6(const ByteArray16& src) : addr_(src) {}
 
 // link-local constructor
-IPAddressV6::IPAddressV6(LinkLocalTag, MacAddress mac)
-  : addr_(mac) {
-}
+IPAddressV6::IPAddressV6(LinkLocalTag, MacAddress mac) : addr_(mac) {}
 
 IPAddressV6::AddressStorage::AddressStorage(MacAddress mac) {
   // The link-local address uses modified EUI-64 format,
@@ -228,9 +216,8 @@ static inline uint16_t unpack(uint8_t lobyte, uint8_t hibyte) {
 
 // given a src string, unpack count*2 bytes into dest
 // dest must have as much storage as count
-static inline void unpackInto(const unsigned char* src,
-                              uint16_t* dest,
-                              size_t count) {
+static inline void
+unpackInto(const unsigned char* src, uint16_t* dest, size_t count) {
   for (size_t i = 0, hi = 1, lo = 0; i < count; i++) {
     dest[i] = unpack(src[hi], src[lo]);
     hi += 2;
@@ -245,7 +232,7 @@ IPAddressV4 IPAddressV6::getIPv4For6To4() const {
         sformat("Invalid IP '{}': not a 6to4 address", str()));
   }
   // convert 16x8 bytes into first 4x16 bytes
-  uint16_t ints[4] = {0,0,0,0};
+  uint16_t ints[4] = {0, 0, 0, 0};
   unpackInto(bytes(), ints, 4);
   // repack into 4x8
   union {
@@ -281,7 +268,7 @@ bool IPAddressV6::isIPv4Mapped() const {
 // public
 IPAddressV6::Type IPAddressV6::type() const {
   // convert 16x8 bytes into first 2x16 bytes
-  uint16_t ints[2] = {0,0};
+  uint16_t ints[2] = {0, 0};
   unpackInto(bytes(), ints, 2);
 
   if ((((uint32_t)ints[0] << 16) | ints[1]) == IPAddressV6::PREFIX_TEREDO) {
@@ -327,11 +314,11 @@ bool IPAddressV6::inSubnet(StringPiece cidrNetwork) const {
 }
 
 // public
-bool IPAddressV6::inSubnetWithMask(const IPAddressV6& subnet,
+bool IPAddressV6::inSubnetWithMask(
+    const IPAddressV6& subnet,
     const ByteArray16& cidrMask) const {
-  const ByteArray16 mask = detail::Bytes::mask(toByteArray(), cidrMask);
-  const ByteArray16 subMask = detail::Bytes::mask(subnet.toByteArray(),
-                                                  cidrMask);
+  const auto mask = detail::Bytes::mask(toByteArray(), cidrMask);
+  const auto subMask = detail::Bytes::mask(subnet.toByteArray(), cidrMask);
   return (mask == subMask);
 }
 
@@ -392,11 +379,24 @@ IPAddressV6 IPAddressV6::getSolicitedNodeAddress() const {
   // addresses
   DCHECK(!isMulticast());
 
-  uint8_t bytes[16] = { 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                        0x00, 0x00, 0x00, 0x01, 0xff, 0x00, 0x00, 0x00 };
-  bytes[13] = addr_.bytes_[13];
-  bytes[14] = addr_.bytes_[14];
-  bytes[15] = addr_.bytes_[15];
+  uint8_t bytes[16] = {
+      0xff,
+      0x02,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x00,
+      0x01,
+      0xff,
+      addr_.bytes_[13],
+      addr_.bytes_[14],
+      addr_.bytes_[15],
+  };
   return IPAddressV6::fromBinary(ByteRange(bytes, 16));
 }
 
@@ -504,7 +504,8 @@ CIDRNetworkV6 IPAddressV6::longestCommonPrefix(
 }
 
 // protected
-bool IPAddressV6::inBinarySubnet(const std::array<uint8_t, 2> addr,
+bool IPAddressV6::inBinarySubnet(
+    const std::array<uint8_t, 2> addr,
     size_t numBits) const {
   auto masked = mask(numBits);
   return (std::memcmp(addr.data(), masked.bytes(), 2) == 0);

folly/IPAddressV6.h

@@ -69,7 +69,9 @@ class IPAddressV6 {
  public:
   // V6 Address Type
   enum Type {
-    TEREDO, T6TO4, NORMAL,
+    TEREDO,
+    T6TO4,
+    NORMAL,
   };
   // A constructor parameter to indicate that we should create a link-local
   // IPAddressV6.
@@ -112,7 +114,7 @@ class IPAddressV6 {
    * Returns the address as a Range.
    */
   ByteRange toBinary() const {
-    return ByteRange((const unsigned char *) &addr_.in6Addr_.s6_addr, 16);
+    return ByteRange((const unsigned char*)&addr_.in6Addr_.s6_addr, 16);
   }
 
   /**
@@ -171,7 +173,9 @@ class IPAddressV6 {
    * @see IPAddress#bitCount
    * @returns 128
    */
-  static size_t bitCount() { return 128; }
+  static size_t bitCount() {
+    return 128;
+  }
 
   /**
    * @see IPAddress#toJson
@@ -188,8 +192,8 @@ class IPAddressV6 {
   bool inSubnet(const IPAddressV6& subnet, uint8_t cidr) const {
     return inSubnetWithMask(subnet, fetchMask(cidr));
   }
-  bool inSubnetWithMask(const IPAddressV6& subnet,
-                        const ByteArray16& mask) const;
+  bool inSubnetWithMask(const IPAddressV6& subnet, const ByteArray16& mask)
+      const;
 
   // @see IPAddress#isLoopback
   bool isLoopback() const;
@@ -256,9 +260,13 @@ class IPAddressV6 {
   IPAddressV6 mask(size_t numBits) const;
 
   // return underlying in6_addr structure
-  in6_addr toAddr() const { return addr_.in6Addr_; }
+  in6_addr toAddr() const {
+    return addr_.in6Addr_;
+  }
 
-  uint16_t getScopeId() const { return scope_; }
+  uint16_t getScopeId() const {
+    return scope_;
+  }
   void setScopeId(uint16_t scope) {
     scope_ = scope;
   }
@@ -290,7 +298,9 @@ class IPAddressV6 {
   std::string str() const;
 
   // @see IPAddress#version
-  uint8_t version() const { return 6; }
+  uint8_t version() const {
+    return 6;
+  }
 
   /**
    * Return the solicited-node multicast address for this address.
@@ -312,32 +322,35 @@ class IPAddressV6 {
       const CIDRNetworkV6& one,
       const CIDRNetworkV6& two);
   // Number of bytes in the address representation.
-  static constexpr size_t byteCount() { return 16; }
+  static constexpr size_t byteCount() {
+    return 16;
+  }
 
-  //get nth most significant bit - 0 indexed
+  // get nth most significant bit - 0 indexed
   bool getNthMSBit(size_t bitIndex) const {
     return detail::getNthMSBitImpl(*this, bitIndex, AF_INET6);
   }
-  //get nth most significant byte - 0 indexed
+  // get nth most significant byte - 0 indexed
   uint8_t getNthMSByte(size_t byteIndex) const;
-  //get nth bit - 0 indexed
+  // get nth bit - 0 indexed
   bool getNthLSBit(size_t bitIndex) const {
     return getNthMSBit(bitCount() - bitIndex - 1);
   }
-  //get nth byte - 0 indexed
+  // get nth byte - 0 indexed
   uint8_t getNthLSByte(size_t byteIndex) const {
     return getNthMSByte(byteCount() - byteIndex - 1);
   }
 
-  const unsigned char* bytes() const { return addr_.in6Addr_.s6_addr; }
+  const unsigned char* bytes() const {
+    return addr_.in6Addr_.s6_addr;
+  }
 
  protected:
   /**
    * Helper that returns true if the address is in the binary subnet specified
    * by addr.
    */
-  bool inBinarySubnet(const std::array<uint8_t, 2> addr,
-                      size_t numBits) const;
+  bool inBinarySubnet(const std::array<uint8_t, 2> addr, size_t numBits) const;
 
  private:
   auto tie() const {
@@ -371,8 +384,8 @@ class IPAddressV6 {
     AddressStorage() {
       std::memset(this, 0, sizeof(AddressStorage));
     }
-    explicit AddressStorage(const ByteArray16& bytes): bytes_(bytes) {}
-    explicit AddressStorage(const in6_addr& addr): in6Addr_(addr) {}
+    explicit AddressStorage(const ByteArray16& bytes) : bytes_(bytes) {}
+    explicit AddressStorage(const in6_addr& addr) : in6Addr_(addr) {}
     explicit AddressStorage(MacAddress mac);
   } addr_;
 

folly/MacAddress.cpp

@@ -73,9 +73,7 @@ string MacAddress::toString() const {
 
 void MacAddress::parse(StringPiece str) {
   // Helper function to convert a single hex char into an integer
-  auto isSeparatorChar = [](char c) {
-    return c == ':' || c == '-';
-  };
+  auto isSeparatorChar = [](char c) { return c == ':' || c == '-'; };
 
   uint8_t parsed[SIZE];
   auto p = str.begin();

folly/MacAddress.h

@@ -222,8 +222,9 @@ class MacAddress {
 
 /* Define toAppend() so to<string> will work */
 template <class Tgt>
-typename std::enable_if<IsSomeString<Tgt>::value>::type
-toAppend(MacAddress address, Tgt* result) {
+typename std::enable_if<IsSomeString<Tgt>::value>::type toAppend(
+    MacAddress address,
+    Tgt* result) {
   toAppend(address.toString(), result);
 }
 

folly/SocketAddress.cpp

@@ -15,7 +15,7 @@
  */
 
 #ifndef __STDC_FORMAT_MACROS
-  #define __STDC_FORMAT_MACROS
+#define __STDC_FORMAT_MACROS
 #endif
 
 #include <folly/SocketAddress.h>
@@ -61,10 +61,7 @@ struct ScopedAddrInfo {
  */
 struct HostAndPort {
   HostAndPort(const char* str, bool hostRequired)
-    : host(nullptr),
-      port(nullptr),
-      allocated(nullptr) {
-
+      : host(nullptr), port(nullptr), allocated(nullptr) {
     // Look for the last colon
     const char* colon = strrchr(str, ':');
     if (colon == nullptr) {
@@ -85,7 +82,7 @@ struct HostAndPort {
       throw std::bad_alloc();
     }
 
-    char *allocatedColon = allocated + (colon - str);
+    char* allocatedColon = allocated + (colon - str);
     *allocatedColon = '\0';
     host = allocated;
     port = allocatedColon + 1;
@@ -167,8 +164,8 @@ void SocketAddress::setFromLocalPort(const char* port) {
 
 void SocketAddress::setFromLocalIpPort(const char* addressAndPort) {
   HostAndPort hp(addressAndPort, false);
-  ScopedAddrInfo results(getAddrInfo(hp.host, hp.port,
-                                     AI_NUMERICHOST | AI_ADDRCONFIG));
+  ScopedAddrInfo results(
+      getAddrInfo(hp.host, hp.port, AI_NUMERICHOST | AI_ADDRCONFIG));
   setFromLocalAddr(results.info);
 }
 
@@ -275,11 +272,12 @@ void SocketAddress::setFromSockaddr(const struct sockaddr* address) {
   setFromIpAddrPort(folly::IPAddress(address), port);
 }
 
-void SocketAddress::setFromSockaddr(const struct sockaddr* address,
+void SocketAddress::setFromSockaddr(
+    const struct sockaddr* address,
     socklen_t addrlen) {
   // Check the length to make sure we can access address->sa_family
-  if (addrlen < (offsetof(struct sockaddr, sa_family) +
-                 sizeof(address->sa_family))) {
+  if (addrlen <
+      (offsetof(struct sockaddr, sa_family) + sizeof(address->sa_family))) {
     throw std::invalid_argument(
         "SocketAddress::setFromSockaddr() called "
         "with length too short for a sockaddr");
@@ -300,8 +298,8 @@ void SocketAddress::setFromSockaddr(const struct sockaddr* address,
     }
     setFromSockaddr(reinterpret_cast<const struct sockaddr_in6*>(address));
   } else if (address->sa_family == AF_UNIX) {
-    setFromSockaddr(reinterpret_cast<const struct sockaddr_un*>(address),
-                    addrlen);
+    setFromSockaddr(
+        reinterpret_cast<const struct sockaddr_un*>(address), addrlen);
   } else {
     throw std::invalid_argument(
         "SocketAddress::setFromSockaddr() called "
@@ -319,7 +317,8 @@ void SocketAddress::setFromSockaddr(const struct sockaddr_in6* address) {
   setFromSockaddr((sockaddr*)address);
 }
 
-void SocketAddress::setFromSockaddr(const struct sockaddr_un* address,
+void SocketAddress::setFromSockaddr(
+    const struct sockaddr_un* address,
     socklen_t addrlen) {
   assert(address->sun_family == AF_UNIX);
   if (addrlen > sizeof(struct sockaddr_un)) {
@@ -337,7 +336,7 @@ void SocketAddress::setFromSockaddr(const struct sockaddr_un* address,
 
   // Fill the rest with 0s, just for safety
   if (addrlen < sizeof(struct sockaddr_un)) {
-    char *p = reinterpret_cast<char*>(storage_.un.addr);
+    char* p = reinterpret_cast<char*>(storage_.un.addr);
     memset(p + addrlen, 0, sizeof(struct sockaddr_un) - addrlen);
   }
 }
@@ -488,16 +487,14 @@ std::string SocketAddress::describe() const {
   switch (getFamily()) {
     case AF_UNSPEC:
       return "<uninitialized address>";
-    case AF_INET:
-    {
+    case AF_INET: {
       char buf[NI_MAXHOST + 16];
       getAddressStr(buf, sizeof(buf));
       size_t iplen = strlen(buf);
       snprintf(buf + iplen, sizeof(buf) - iplen, ":%" PRIu16, getPort());
       return buf;
     }
-    case AF_INET6:
-    {
+    case AF_INET6: {
       char buf[NI_MAXHOST + 18];
       buf[0] = '[';
       getAddressStr(buf + 1, sizeof(buf) - 1);
@@ -505,11 +502,9 @@ std::string SocketAddress::describe() const {
       snprintf(buf + iplen, sizeof(buf) - iplen, "]:%" PRIu16, getPort());
       return buf;
     }
-    default:
-    {
+    default: {
       char buf[64];
-      snprintf(buf, sizeof(buf), "<unknown address family %d>",
-               getFamily());
+      snprintf(buf, sizeof(buf), "<unknown address family %d>", getFamily());
       return buf;
     }
   }
@@ -521,8 +516,7 @@ bool SocketAddress::operator==(const SocketAddress& other) const {
   }
   if (external_) {
     // anonymous addresses are never equal to any other addresses
-    if (storage_.un.pathLength() == 0 ||
-        other.storage_.un.pathLength() == 0) {
+    if (storage_.un.pathLength() == 0 || other.storage_.un.pathLength() == 0) {
       return false;
     }
 
@@ -539,8 +533,7 @@ bool SocketAddress::operator==(const SocketAddress& other) const {
   switch (getFamily()) {
     case AF_INET:
     case AF_INET6:
-      return (other.storage_.addr == storage_.addr) &&
-        (other.port_ == port_);
+      return (other.storage_.addr == storage_.addr) && (other.port_ == port_);
     default:
       throw std::invalid_argument(
           "SocketAddress: unsupported address family "
@@ -548,7 +541,8 @@ bool SocketAddress::operator==(const SocketAddress& other) const {
   }
 }
 
-bool SocketAddress::prefixMatch(const SocketAddress& other,
+bool SocketAddress::prefixMatch(
+    const SocketAddress& other,
     unsigned prefixLength) const {
   if (other.getFamily() != getFamily()) {
     return false;
@@ -558,11 +552,9 @@ bool SocketAddress::prefixMatch(const SocketAddress& other,
     case AF_INET:
       mask_length = 32;
       FOLLY_FALLTHROUGH;
-    case AF_INET6:
-    {
+    case AF_INET6: {
       auto prefix = folly::IPAddress::longestCommonPrefix(
-        {storage_.addr, mask_length},
-        {other.storage_.addr, mask_length});
+          {storage_.addr, mask_length}, {other.storage_.addr, mask_length});
       return prefix.second >= prefixLength;
     }
     default:
@@ -570,13 +562,12 @@ bool SocketAddress::prefixMatch(const SocketAddress& other,
   }
 }
 
-
 size_t SocketAddress::hash() const {
   size_t seed = folly::hash::twang_mix64(getFamily());
 
   if (external_) {
     enum { kUnixPathMax = sizeof(storage_.un.addr->sun_path) };
-    const char *path = storage_.un.addr->sun_path;
+    const char* path = storage_.un.addr->sun_path;
     auto pathLength = storage_.un.pathLength();
     // TODO: this probably could be made more efficient
     for (off_t n = 0; n < pathLength; ++n) {
@@ -604,9 +595,8 @@ size_t SocketAddress::hash() const {
   return seed;
 }
 
-struct addrinfo* SocketAddress::getAddrInfo(const char* host,
-                                             uint16_t port,
-                                             int flags) {
+struct addrinfo*
+SocketAddress::getAddrInfo(const char* host, uint16_t port, int flags) {
   // getaddrinfo() requires the port number as a string
   char portString[sizeof("65535")];
   snprintf(portString, sizeof(portString), "%" PRIu16, port);
@@ -614,16 +604,15 @@ struct addrinfo* SocketAddress::getAddrInfo(const char* host,
   return getAddrInfo(host, portString, flags);
 }
 
-struct addrinfo* SocketAddress::getAddrInfo(const char* host,
-                                             const char* port,
-                                             int flags) {
+struct addrinfo*
+SocketAddress::getAddrInfo(const char* host, const char* port, int flags) {
   struct addrinfo hints;
   memset(&hints, 0, sizeof(hints));
   hints.ai_family = AF_UNSPEC;
   hints.ai_socktype = SOCK_STREAM;
   hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV | flags;
 
-  struct addrinfo *results;
+  struct addrinfo* results;
   int error = getaddrinfo(host, port, &hints, &results);
   if (error != 0) {
     auto os = folly::sformat(
@@ -674,10 +663,9 @@ std::string SocketAddress::getIpString(int flags) const {
   return std::string(addrString);
 }
 
-void SocketAddress::getIpString(char *buf, size_t buflen, int flags) const {
+void SocketAddress::getIpString(char* buf, size_t buflen, int flags) const {
   auto family = getFamily();
-  if (family != AF_INET &&
-      family != AF_INET6) {
+  if (family != AF_INET && family != AF_INET6) {
     throw std::invalid_argument(
         "SocketAddress: attempting to get IP address "
         "for a non-IP address");
@@ -685,8 +673,14 @@ void SocketAddress::getIpString(char *buf, size_t buflen, int flags) const {
 
   sockaddr_storage tmp_sock;
   storage_.addr.toSockaddrStorage(&tmp_sock, port_);
-  int rc = getnameinfo((sockaddr*)&tmp_sock, sizeof(sockaddr_storage),
-                       buf, buflen, nullptr, 0, flags);
+  int rc = getnameinfo(
+      (sockaddr*)&tmp_sock,
+      sizeof(sockaddr_storage),
+      buf,
+      buflen,
+      nullptr,
+      0,
+      flags);
   if (rc != 0) {
     auto os = sformat(
         "getnameinfo() failed in getIpString() error = {}", gai_strerror(rc));
@@ -755,8 +749,7 @@ bool SocketAddress::operator<(const SocketAddress& other) const {
         return port_ < other.port_;
       }
 
-      return
-        storage_.addr < other.storage_.addr;
+      return storage_.addr < other.storage_.addr;
     }
     case AF_UNSPEC:
     default:

folly/SocketAddress.h

@@ -47,8 +47,7 @@ class SocketAddress {
    *        This is potentially a very slow operation, so is disabled by
    *        default.
    */
-  SocketAddress(const char* host, uint16_t port,
-                 bool allowNameLookup = false) {
+  SocketAddress(const char* host, uint16_t port, bool allowNameLookup = false) {
     // Initialize the address family first,
     // since setFromHostPort() and setFromIpPort() will check it.
 
@@ -59,7 +58,9 @@ class SocketAddress {
     }
   }
 
-  SocketAddress(const std::string& host, uint16_t port,
+  SocketAddress(
+      const std::string& host,
+      uint16_t port,
       bool allowNameLookup = false) {
     // Initialize the address family first,
     // since setFromHostPort() and setFromIpPort() will check it.
@@ -342,8 +343,7 @@ class SocketAddress {
    *                 enough for the full address type required by
    *                 address->sa_family.
    */
-  void setFromSockaddr(const struct sockaddr* address,
-                       socklen_t addrlen);
+  void setFromSockaddr(const struct sockaddr* address, socklen_t addrlen);
 
   /**
    * Initialize this SocketAddress from a struct sockaddr_in.
@@ -367,9 +367,7 @@ class SocketAddress {
    *                 the valid bytes of sun_path, not including any NUL
    *                 terminator.
    */
-  void setFromSockaddr(const struct sockaddr_un* address,
-                       socklen_t addrlen);
-
+  void setFromSockaddr(const struct sockaddr_un* address, socklen_t addrlen);
 
   /**
    * Fill in a given sockaddr_storage with the ip or unix address.
@@ -445,8 +443,7 @@ class SocketAddress {
    * Return true if this is an IPv4-mapped IPv6 address.
    */
   bool isIPv4Mapped() const {
-    return (getFamily() == AF_INET6 &&
-            storage_.addr.isIPv4Mapped());
+    return (getFamily() == AF_INET6 && storage_.addr.isIPv4Mapped());
   }
 
   /**
@@ -540,7 +537,7 @@ class SocketAddress {
    * the heap.
    */
   struct ExternalUnixAddr {
-    struct sockaddr_un *addr;
+    struct sockaddr_un* addr;
     socklen_t len;
 
     socklen_t pathLength() const {
@@ -552,12 +549,12 @@ class SocketAddress {
       addr->sun_family = AF_UNIX;
       len = 0;
     }
-    void init(const ExternalUnixAddr &other) {
+    void init(const ExternalUnixAddr& other) {
       addr = new struct sockaddr_un;
       len = other.len;
       memcpy(addr, other.addr, size_t(len));
     }
-    void copy(const ExternalUnixAddr &other) {
+    void copy(const ExternalUnixAddr& other) {
       len = other.len;
       memcpy(addr, other.addr, size_t(len));
     }
@@ -572,7 +569,7 @@ class SocketAddress {
   void setFromLocalAddr(const struct addrinfo* results);
   void setFromSocket(int socket, int (*fn)(int, struct sockaddr*, socklen_t*));
   std::string getIpString(int flags) const;
-  void getIpString(char *buf, size_t buflen, int flags) const;
+  void getIpString(char* buf, size_t buflen, int flags) const;
 
   void updateUnixAddressLength(socklen_t addrlen);
 
@@ -603,7 +600,6 @@ class SocketAddress {
 size_t hash_value(const SocketAddress& address);
 
 std::ostream& operator<<(std::ostream& os, const SocketAddress& addr);
-
 }
 
 namespace std {
@@ -611,10 +607,8 @@ namespace std {
 // Provide an implementation for std::hash<SocketAddress>
 template <>
 struct hash<folly::SocketAddress> {
-  size_t operator()(
-      const folly::SocketAddress& addr) const {
+  size_t operator()(const folly::SocketAddress& addr) const {
     return addr.hash();
   }
 };
-
 }

folly/detail/IPAddress.cpp

@@ -18,7 +18,8 @@
 
 #include <folly/Format.h>
 
-namespace folly { namespace detail {
+namespace folly {
+namespace detail {
 
 std::string familyNameStrDefault(sa_family_t family) {
   return sformat("sa_family_t({})", family);
@@ -30,5 +31,5 @@ std::string familyNameStrDefault(sa_family_t family) {
       bitCount,
       familyNameStr(family)));
 }
-
-}}
+} // namespace detail
+} // namespace folly

folly/detail/IPAddress.h

@@ -22,7 +22,8 @@
 
 #include <folly/portability/Sockets.h>
 
-namespace folly { namespace detail {
+namespace folly {
+namespace detail {
 
 std::string familyNameStrDefault(sa_family_t family);
 
@@ -49,8 +50,8 @@ getNthMSBitImpl(const IPAddrType& ip, size_t bitIndex, sa_family_t family) {
   if (bitIndex >= ip.bitCount()) {
     getNthMSBitImplThrow(ip.bitCount(), family);
   }
-  //Underlying bytes are in n/w byte order
+  // Underlying bytes are in n/w byte order
   return (ip.getNthMSByte(bitIndex / 8) & (0x80 >> (bitIndex % 8))) != 0;
 }
-
-}}  // folly::detail
+} // namespace detail
+} // namespace folly

folly/test/IPAddressBenchmark.cpp

@@ -30,11 +30,8 @@ BENCHMARK(ipv4_to_string_inet_ntop, iters) {
   char outputString[INET_ADDRSTRLEN] = {0};
 
   while (iters--) {
-    const char* val = inet_ntop(
-      AF_INET,
-      &ip,
-      outputString,
-      sizeof(outputString));
+    const char* val =
+        inet_ntop(AF_INET, &ip, outputString, sizeof(outputString));
   }
 }
 
@@ -78,11 +75,8 @@ BENCHMARK(ipv6_to_string_inet_ntop, iters) {
   bool checkResult = (iters == 1);
 
   while (iters--) {
-    const char* val = inet_ntop(
-      AF_INET6,
-      &ip,
-      outputString,
-      sizeof(outputString));
+    const char* val =
+        inet_ntop(AF_INET6, &ip, outputString, sizeof(outputString));
   }
 }
 
@@ -135,7 +129,7 @@ BENCHMARK_RELATIVE(ipv6_append_to_fully_qualified_port, iters) {
 // ipv6_append_to_fully_qualified_port              178.73%    84.35ns   11.86M
 // ============================================================================
 
-int main(int argc, char *argv[]) {
+int main(int argc, char* argv[]) {
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   runBenchmarks();
   return 0;

folly/test/IPAddressTest.cpp

@@ -244,7 +244,7 @@ TEST(IPAddress, InvalidAddressFamilyExceptions) {
     sockaddr_in addr;
     addr.sin_family = AF_UNSPEC;
 
-    EXPECT_THROW(IPAddress((sockaddr *)&addr), InvalidAddressFamilyException);
+    EXPECT_THROW(IPAddress((sockaddr*)&addr), InvalidAddressFamilyException);
   }
 }
 
@@ -284,8 +284,8 @@ TEST(IPAddress, CreateNetwork) {
   // test empty string
   EXPECT_THROW(IPAddress::createNetwork(""), IPAddressFormatException);
   // test multi slash string
-  EXPECT_THROW(IPAddress::createNetwork("192.168.0.1/24/36"),
-                                        IPAddressFormatException);
+  EXPECT_THROW(
+      IPAddress::createNetwork("192.168.0.1/24/36"), IPAddressFormatException);
   // test no slash string with default IPv4
   {
     auto net = IPAddress::createNetwork("192.168.0.1");
@@ -305,9 +305,8 @@ TEST(IPAddress, CreateNetwork) {
     EXPECT_EQ(128, net.second);
   }
   // test no slash string with invalid default
-  EXPECT_THROW(IPAddress::createNetwork("192.168.0.1", 33),
-               IPAddressFormatException);
-
+  EXPECT_THROW(
+      IPAddress::createNetwork("192.168.0.1", 33), IPAddressFormatException);
 }
 
 // test assignment operators
@@ -450,7 +449,7 @@ TEST(IPAddress, CtorSockaddr) {
     addr.sin_family = AF_INET;
     addr.sin_addr = sin_addr;
 
-    IPAddress ipAddr((sockaddr *)&addr);
+    IPAddress ipAddr((sockaddr*)&addr);
     EXPECT_TRUE(ipAddr.isV4());
     EXPECT_EQ("126.131.128.23", ipAddr.str());
   }
@@ -460,21 +459,20 @@ TEST(IPAddress, CtorSockaddr) {
     sockaddr_in6 addr;
     memset(&addr, 0, sizeof(addr));
     in6_addr sin_addr;
-    ByteArray16 sec{{
     // 2620:0:1cfe:face:b00c::3
-      38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3
-    }};
+    ByteArray16 sec{
+        {38, 32, 0, 0, 28, 254, 250, 206, 176, 12, 0, 0, 0, 0, 0, 3}};
     std::memcpy(sin_addr.s6_addr, sec.data(), 16);
     addr.sin6_family = AF_INET6;
     addr.sin6_addr = sin_addr;
 
-    IPAddress ipAddr((sockaddr *)&addr);
+    IPAddress ipAddr((sockaddr*)&addr);
     EXPECT_TRUE(ipAddr.isV6());
     EXPECT_EQ("2620:0:1cfe:face:b00c::3", ipAddr.str());
   }
   // test nullptr exception
   {
-    sockaddr *addr = nullptr;
+    sockaddr* addr = nullptr;
     EXPECT_THROW(IPAddress((const sockaddr*)addr), IPAddressFormatException);
   }
   // test invalid family exception
@@ -486,7 +484,7 @@ TEST(IPAddress, CtorSockaddr) {
     addr.sin_family = AF_UNSPEC;
     addr.sin_addr = sin_addr;
 
-    EXPECT_THROW(IPAddress((sockaddr *)&addr), IPAddressFormatException);
+    EXPECT_THROW(IPAddress((sockaddr*)&addr), IPAddressFormatException);
   }
 }
 
@@ -519,7 +517,7 @@ TEST(IPAddress, ToSockaddrStorage) {
   }
   // test nullptr exception
   {
-    sockaddr_storage *out = nullptr;
+    sockaddr_storage* out = nullptr;
     IPAddress addr("127.0.0.1");
     EXPECT_THROW(addr.toSockaddrStorage(out), IPAddressFormatException);
   }
@@ -546,9 +544,16 @@ TEST(IPAddress, ToString) {
   EXPECT_EQ("1:2::3", folly::to<string>(addr_1_2_3));
 
   // Test a combination of all the above arguments
-  EXPECT_EQ("1:2::3 - 10.0.0.1 - ::1 - 10.1.2.3",
-            folly::to<string>(addr_1_2_3, " - ", addr_10_0_0_1,
-                              " - ", addr_1, " - ", addr_10_1_2_3));
+  EXPECT_EQ(
+      "1:2::3 - 10.0.0.1 - ::1 - 10.1.2.3",
+      folly::to<string>(
+          addr_1_2_3,
+          " - ",
+          addr_10_0_0_1,
+          " - ",
+          addr_1,
+          " - ",
+          addr_10_1_2_3));
 }
 
 TEST(IPaddress, toInverseArpaName) {
@@ -584,7 +589,8 @@ TEST_P(IPAddressCtorTest, InvalidCreation) {
 // Test that invalid binary values throw an exception
 TEST_P(IPAddressCtorBinaryTest, InvalidBinary) {
   auto bin = GetParam();
-  EXPECT_THROW(IPAddress::fromBinary(ByteRange(&bin[0], bin.size())),
+  EXPECT_THROW(
+      IPAddress::fromBinary(ByteRange(&bin[0], bin.size())),
       IPAddressFormatException);
 }
 
@@ -732,7 +738,7 @@ TEST(IPAddress, getIPv6For6To4) {
   }
 }
 
-static const vector<pair<string, uint8_t> > invalidMasks = {
+static const vector<pair<string, uint8_t>> invalidMasks = {
     {"127.0.0.1", 33},
     {"::1", 129},
 };
@@ -743,7 +749,7 @@ TEST(IPAddress, InvalidMask) {
   }
 }
 
-static const vector<pair<string, IPAddressV6::Type> > v6types = {
+static const vector<pair<string, IPAddressV6::Type>> v6types = {
     {"::1", IPAddressV6::Type::NORMAL},
     {"2620:0:1cfe:face:b00c::3", IPAddressV6::Type::NORMAL},
     {"2001:0000:4136:e378:8000:63bf:3fff:fdd2", IPAddressV6::Type::TEREDO},
@@ -786,7 +792,7 @@ TEST(IPAddress, V6Types) {
   }
 }
 
-static const vector<pair<string, uint32_t> > provideToLong = {
+static const vector<pair<string, uint32_t>> provideToLong = {
     {"0.0.0.0", 0},
     {"10.0.0.0", 167772160},
     {"126.131.128.23", 2122547223},
@@ -837,12 +843,12 @@ TEST(IPAddress, fromBinaryV4) {
   }
 
   uint8_t data[20];
-  EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 3)),
-               IPAddressFormatException);
-  EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 16)),
-               IPAddressFormatException);
-  EXPECT_THROW(IPAddressV4::fromBinary(ByteRange(data, 20)),
-               IPAddressFormatException);
+  EXPECT_THROW(
+      IPAddressV4::fromBinary(ByteRange(data, 3)), IPAddressFormatException);
+  EXPECT_THROW(
+      IPAddressV4::fromBinary(ByteRange(data, 16)), IPAddressFormatException);
+  EXPECT_THROW(
+      IPAddressV4::fromBinary(ByteRange(data, 20)), IPAddressFormatException);
 }
 
 TEST(IPAddress, toBinaryV4) {
@@ -861,22 +867,44 @@ TEST(IPAddress, toBinaryV4) {
   }
 }
 
-static const vector<pair<string, vector<uint8_t> > > provideBinary16Bytes = {
-  {"::0",
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
-  {"1::2",
-    {0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}},
-  {"fe80::0012:34ff:fe56:78ab",
-    {0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0x00, 0x12, 0x34, 0xff, 0xfe, 0x56, 0x78, 0xab}},
-  {"2001:db8:1234:5678:90ab:cdef:8765:4321",
-    {0x20, 0x01, 0x0d, 0xb8, 0x12, 0x34, 0x56, 0x78,
-     0x90, 0xab, 0xcd, 0xef, 0x87, 0x65, 0x43, 0x21}},
-  {"::ffff:0:c0a8:1",
-    {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-     0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}},
+using ByteArray8 = std::array<uint8_t, 8>;
+
+static auto join8 = [](std::array<ByteArray8, 2> parts) {
+  ByteArray16 _return;
+  std::memcpy(_return.data(), parts.data(), _return.size());
+  return _return;
+};
+
+static const vector<pair<string, ByteArray16>> provideBinary16Bytes = {
+    make_pair(
+        "::0",
+        join8({{
+            ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
+            ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
+        }})),
+    make_pair(
+        "1::2",
+        join8({{
+            ByteArray8{{0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
+            ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}},
+        }})),
+    make_pair(
+        "fe80::0012:34ff:fe56:78ab",
+        join8(
+            {{ByteArray8{{0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
+              ByteArray8{{0x00, 0x12, 0x34, 0xff, 0xfe, 0x56, 0x78, 0xab}}}})),
+    make_pair(
+        "2001:db8:1234:5678:90ab:cdef:8765:4321",
+        join8({{
+            ByteArray8{{0x20, 0x01, 0x0d, 0xb8, 0x12, 0x34, 0x56, 0x78}},
+            ByteArray8{{0x90, 0xab, 0xcd, 0xef, 0x87, 0x65, 0x43, 0x21}},
+        }})),
+    make_pair(
+        "::ffff:0:c0a8:1",
+        join8({{
+            ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
+            ByteArray8{{0xff, 0xff, 0x00, 0x00, 0xc0, 0xa8, 0x00, 0x01}},
+        }})),
 };
 
 TEST(IPAddress, fromBinaryV6) {
@@ -899,12 +927,12 @@ TEST(IPAddress, fromBinaryV6) {
   }
 
   uint8_t data[20];
-  EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 3)),
-               IPAddressFormatException);
-  EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 4)),
-               IPAddressFormatException);
-  EXPECT_THROW(IPAddressV6::fromBinary(ByteRange(data, 20)),
-               IPAddressFormatException);
+  EXPECT_THROW(
+      IPAddressV6::fromBinary(ByteRange(data, 3)), IPAddressFormatException);
+  EXPECT_THROW(
+      IPAddressV6::fromBinary(ByteRange(data, 4)), IPAddressFormatException);
+  EXPECT_THROW(
+      IPAddressV6::fromBinary(ByteRange(data, 20)), IPAddressFormatException);
 }
 
 TEST(IPAddress, toBinaryV6) {
@@ -973,12 +1001,14 @@ TEST_P(IPAddressFlagTest, IsLinkLocalBroadcast) {
 
 TEST(IPAddress, SolicitedNodeAddress) {
   // An example from RFC 4291 section 2.7.1
-  EXPECT_EQ(IPAddressV6("ff02::1:ff0e:8c6c"),
+  EXPECT_EQ(
+      IPAddressV6("ff02::1:ff0e:8c6c"),
       IPAddressV6("4037::01:800:200e:8c6c").getSolicitedNodeAddress());
 
   // An example from wikipedia
   // (http://en.wikipedia.org/wiki/Solicited-node_multicast_address)
-  EXPECT_EQ(IPAddressV6("ff02::1:ff28:9c5a"),
+  EXPECT_EQ(
+      IPAddressV6("ff02::1:ff28:9c5a"),
       IPAddressV6("fe80::2aa:ff:fe28:9c5a").getSolicitedNodeAddress());
 }
 
@@ -988,42 +1018,46 @@ TEST_P(IPAddressByteAccessorTest, CheckBytes) {
   size_t i = 0;
   for (auto byitr = addrData.bytes.begin(); i < ip.byteCount(); ++i, ++byitr) {
     EXPECT_EQ(*byitr, ip.getNthMSByte(i));
-    EXPECT_EQ(*byitr, ip.isV4() ?
-          ip.asV4().getNthMSByte(i) : ip.asV6().getNthMSByte(i));
+    EXPECT_EQ(
+        *byitr,
+        ip.isV4() ? ip.asV4().getNthMSByte(i) : ip.asV6().getNthMSByte(i));
   }
   i = 0;
-  for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount(); ++i,
-      ++byritr) {
+  for (auto byritr = addrData.bytes.rbegin(); i < ip.byteCount();
+       ++i, ++byritr) {
     EXPECT_EQ(*byritr, ip.getNthLSByte(i));
-    EXPECT_EQ(*byritr, ip.isV4() ?
-        ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i));
+    EXPECT_EQ(
+        *byritr,
+        ip.isV4() ? ip.asV4().getNthLSByte(i) : ip.asV6().getNthLSByte(i));
   }
 }
 
 TEST_P(IPAddressBitAccessorTest, CheckBits) {
   auto addrData = GetParam();
   auto littleEndianAddrData = addrData.bytes;
-  //IPAddress stores address data in n/w byte order.
+  // IPAddress stores address data in n/w byte order.
   reverse(littleEndianAddrData.begin(), littleEndianAddrData.end());
-  //Bit iterator goes from LSBit to MSBit
-  //We will traverse the IPAddress bits from 0 to bitCount -1
+  // Bit iterator goes from LSBit to MSBit
+  // We will traverse the IPAddress bits from 0 to bitCount -1
   auto bitr = folly::makeBitIterator(littleEndianAddrData.begin());
   IPAddress ip(addrData.address);
   for (size_t i = 0; i < ip.bitCount(); ++i) {
     auto msbIndex = ip.bitCount() - i - 1;
     EXPECT_EQ(*bitr, ip.getNthMSBit(msbIndex));
-    EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthMSBit(msbIndex) :
-          ip.asV6().getNthMSBit(msbIndex));
+    EXPECT_EQ(
+        *bitr,
+        ip.isV4() ? ip.asV4().getNthMSBit(msbIndex)
+                  : ip.asV6().getNthMSBit(msbIndex));
     EXPECT_EQ(*bitr, ip.getNthLSBit(i));
-    EXPECT_EQ(*bitr, ip.isV4() ? ip.asV4().getNthLSBit(i) :
-        ip.asV6().getNthLSBit(i));
+    EXPECT_EQ(
+        *bitr, ip.isV4() ? ip.asV4().getNthLSBit(i) : ip.asV6().getNthLSBit(i));
     ++bitr;
   }
 }
 
 TEST(IPAddress, InvalidByteAccess) {
   IPAddress ip4("10.10.10.10");
-  //MSByte, LSByte accessors are 0 indexed
+  // MSByte, LSByte accessors are 0 indexed
   EXPECT_THROW(ip4.getNthMSByte(ip4.byteCount()), std::invalid_argument);
   EXPECT_THROW(ip4.getNthLSByte(ip4.byteCount()), std::invalid_argument);
   EXPECT_THROW(ip4.getNthMSByte(-1), std::invalid_argument);
@@ -1044,12 +1078,11 @@ TEST(IPAddress, InvalidByteAccess) {
   EXPECT_THROW(asV6.getNthLSByte(asV6.byteCount()), std::invalid_argument);
   EXPECT_THROW(asV6.getNthMSByte(-1), std::invalid_argument);
   EXPECT_THROW(asV6.getNthLSByte(-1), std::invalid_argument);
-
 }
 
 TEST(IPAddress, InvalidBBitAccess) {
   IPAddress ip4("10.10.10.10");
-  //MSByte, LSByte accessors are 0 indexed
+  // MSByte, LSByte accessors are 0 indexed
   EXPECT_THROW(ip4.getNthMSBit(ip4.bitCount()), std::invalid_argument);
   EXPECT_THROW(ip4.getNthLSBit(ip4.bitCount()), std::invalid_argument);
   EXPECT_THROW(ip4.getNthMSBit(-1), std::invalid_argument);
@@ -1082,8 +1115,8 @@ TEST(IPAddress, StringFormat) {
     a6.s6_addr16[i] = t;
 #endif
   }
-  EXPECT_EQ("0123:4567:89ab:cdef:0123:4567:89ab:cdef",
-            detail::fastIpv6ToString(a6));
+  EXPECT_EQ(
+      "0123:4567:89ab:cdef:0123:4567:89ab:cdef", detail::fastIpv6ToString(a6));
 
   in_addr a4;
   a4.s_addr = htonl(0x01020304);
@@ -1114,8 +1147,8 @@ TEST(IPAddress, LongestCommonPrefix) {
   IPAddress ip128("128.0.0.0");
   IPAddress ip10dot10("10.10.0.0");
   auto prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip128, 8});
-  auto prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
-                                                  {ip128.asV4(), 8});
+  auto prefix4 =
+      IPAddressV4::longestCommonPrefix({ip10.asV4(), 8}, {ip128.asV4(), 8});
   // No bits match b/w 128/8 and 10/8
   EXPECT_EQ(IPAddress("0.0.0.0"), prefix.first);
   EXPECT_EQ(0, prefix.second);
@@ -1123,8 +1156,8 @@ TEST(IPAddress, LongestCommonPrefix) {
   EXPECT_EQ(0, prefix4.second);
 
   prefix = IPAddress::longestCommonPrefix({ip10, 8}, {ip10dot10, 16});
-  prefix4 = IPAddressV4::longestCommonPrefix({ip10.asV4(), 8},
-                                             {ip10dot10.asV4(), 16});
+  prefix4 = IPAddressV4::longestCommonPrefix(
+      {ip10.asV4(), 8}, {ip10dot10.asV4(), 16});
   // Between 10/8 and 10.10/16, 10/8 is the longest common match
   EXPECT_EQ(ip10, prefix.first);
   EXPECT_EQ(8, prefix.second);
@@ -1132,8 +1165,8 @@ TEST(IPAddress, LongestCommonPrefix) {
   EXPECT_EQ(8, prefix4.second);
 
   prefix = IPAddress::longestCommonPrefix({ip11, 8}, {ip12, 8});
-  prefix4 = IPAddressV4::longestCommonPrefix({ip11.asV4(), 8},
-                                             {ip12.asV4(), 8});
+  prefix4 =
+      IPAddressV4::longestCommonPrefix({ip11.asV4(), 8}, {ip12.asV4(), 8});
   // 12 = 1100, 11 = 1011, longest match - 1000 = 8
   EXPECT_EQ(IPAddress("8.0.0.0"), prefix.first);
   EXPECT_EQ(5, prefix.second);
@@ -1142,16 +1175,16 @@ TEST(IPAddress, LongestCommonPrefix) {
 
   // Between 128/1 and 128/2, longest match 128/1
   prefix = IPAddress::longestCommonPrefix({ip128, 1}, {ip128, 2});
-  prefix4 = IPAddressV4::longestCommonPrefix({ip128.asV4(), 1},
-                                             {ip128.asV4(), 2});
+  prefix4 =
+      IPAddressV4::longestCommonPrefix({ip128.asV4(), 1}, {ip128.asV4(), 2});
   EXPECT_EQ(ip128, prefix.first);
   EXPECT_EQ(1, prefix.second);
   EXPECT_EQ(ip128.asV4(), prefix4.first);
   EXPECT_EQ(1, prefix4.second);
 
   IPAddress ip6("2620:0:1cfe:face:b00c::3");
-  prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()},
-                                          {ip6, ip6.bitCount()});
+  prefix = IPAddress::longestCommonPrefix(
+      {ip6, ip6.bitCount()}, {ip6, ip6.bitCount()});
   auto prefix6 = IPAddressV6::longestCommonPrefix(
       {ip6.asV6(), IPAddressV6::bitCount()},
       {ip6.asV6(), IPAddressV6::bitCount()});
@@ -1164,40 +1197,42 @@ TEST(IPAddress, LongestCommonPrefix) {
   IPAddress ip6Zero("::");
   prefix = IPAddress::longestCommonPrefix({ip6, ip6.bitCount()}, {ip6Zero, 0});
   prefix6 = IPAddressV6::longestCommonPrefix(
-    {ip6.asV6(), IPAddressV6::bitCount()},
-    {ip6Zero.asV6(), 0});
+      {ip6.asV6(), IPAddressV6::bitCount()}, {ip6Zero.asV6(), 0});
   // Longest common b/w :: (ipv6 equivalent of 0/0) is ::
   EXPECT_EQ(ip6Zero, prefix.first);
   EXPECT_EQ(0, prefix.second);
 
   // Exceptional cases
-  EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}),
+  EXPECT_THROW(
+      IPAddress::longestCommonPrefix({ip10, 8}, {ip6, 128}),
       std::invalid_argument);
-  EXPECT_THROW(IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1},
-                                              {ip10, 8}),
+  EXPECT_THROW(
+      IPAddress::longestCommonPrefix({ip10, ip10.bitCount() + 1}, {ip10, 8}),
       std::invalid_argument);
-  EXPECT_THROW(IPAddressV4::longestCommonPrefix(
-                 {ip10.asV4(), IPAddressV4::bitCount() + 1},
-                 {ip10.asV4(), 8}),
+  EXPECT_THROW(
+      IPAddressV4::longestCommonPrefix(
+          {ip10.asV4(), IPAddressV4::bitCount() + 1}, {ip10.asV4(), 8}),
       std::invalid_argument);
-  EXPECT_THROW(IPAddress::longestCommonPrefix({ip6, ip6.bitCount() + 1},
-                                              {ip6, ip6.bitCount()}),
+  EXPECT_THROW(
+      IPAddress::longestCommonPrefix(
+          {ip6, ip6.bitCount() + 1}, {ip6, ip6.bitCount()}),
       std::invalid_argument);
-  EXPECT_THROW(IPAddressV6::longestCommonPrefix(
+  EXPECT_THROW(
+      IPAddressV6::longestCommonPrefix(
           {ip6.asV6(), IPAddressV6::bitCount() + 1},
           {ip6.asV6(), IPAddressV6::bitCount()}),
       std::invalid_argument);
-
 }
 
 static const vector<AddressData> validAddressProvider = {
-  AddressData("127.0.0.1", {127,0,0,1}, 4),
-  AddressData("69.63.189.16", {69,63,189,16}, 4),
-  AddressData("0.0.0.0", {0,0,0,0}, 4),
-  AddressData("::1",
-              {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1}, 6),
-  AddressData("2620:0:1cfe:face:b00c::3",
-              {38,32,0,0,28,254,250,206,176,12,0,0,0,0,0,3}, 6),
+    AddressData("127.0.0.1", {127, 0, 0, 1}, 4),
+    AddressData("69.63.189.16", {69, 63, 189, 16}, 4),
+    AddressData("0.0.0.0", {0, 0, 0, 0}, 4),
+    AddressData("::1", {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}, 6),
+    AddressData(
+        "2620:0:1cfe:face:b00c::3",
+        {38, 32, 0, 0, 28, 254, 250, 206, 176, 12, 0, 0, 0, 0, 0, 3},
+        6),
 };
 
 static const vector<string> invalidAddressProvider = {
@@ -1230,7 +1265,7 @@ static const uint8_t IS_LINK_LOCAL =
 static const uint8_t IS_PVT_NONROUTE = IS_NONROUTABLE | IS_PRIVATE;
 static const uint8_t IS_MULTICAST = AddressFlags::IS_MULTICAST;
 static const uint8_t IS_LINK_LOCAL_BROADCAST =
-AddressFlags::IS_LINK_LOCAL_BROADCAST;
+    AddressFlags::IS_LINK_LOCAL_BROADCAST;
 
 static vector<AddressFlags> flagProvider = {
     // public v4
@@ -1280,7 +1315,10 @@ static vector<AddressFlags> flagProvider = {
     AddressFlags("240.0.0.0", 4, IS_NONROUTABLE),
     AddressFlags("224.0.0.0", 4, IS_NONROUTABLE),
     // v4 link local broadcast
-  AddressFlags("255.255.255.255", 4, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
+    AddressFlags(
+        "255.255.255.255",
+        4,
+        IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
 
     // non routable v6
     AddressFlags("1999::1", 6, IS_NONROUTABLE),
@@ -1293,7 +1331,7 @@ static vector<AddressFlags> flagProvider = {
     AddressFlags("fe80::0012:34ff:fe56:7890", 6, IS_LINK_LOCAL),
 
     // multicast v4
-  AddressFlags("224.0.0.1", 4, IS_MULTICAST | IS_NONROUTABLE) ,
+    AddressFlags("224.0.0.1", 4, IS_MULTICAST | IS_NONROUTABLE),
     AddressFlags("224.0.0.251", 4, IS_MULTICAST | IS_NONROUTABLE),
     AddressFlags("239.12.34.56", 4, IS_MULTICAST | IS_NONROUTABLE),
 
@@ -1306,7 +1344,7 @@ static vector<AddressFlags> flagProvider = {
     AddressFlags("ff02::1", 6, IS_NONROUTABLE | IS_LINK_LOCAL_BROADCAST),
 };
 
-static const vector<pair<string, string> > mapProvider = {
+static const vector<pair<string, string>> mapProvider = {
     {"::ffff:192.0.2.128", "192.0.2.128"},
     {"192.0.2.128", "::ffff:192.0.2.128"},
     {"::FFFF:129.144.52.38", "129.144.52.38"},
@@ -1356,7 +1394,7 @@ static const vector<MaskData> masksProvider = {
     MaskData("2620:0:1cfe:face:b00c::3", 78, "2620:0:1cfe:face:b00c::"),
     MaskData("2620:0:1cfe:face:b00c::3", 127, "2620:0:1cfe:face:b00c::2"),
     MaskData("2620:0:1cfe:face:b00c::3", 128, "2620:0:1cfe:face:b00c::3"),
-  MaskData("2620:0:1cfe:face:b00c::3", 0, "::")
+    MaskData("2620:0:1cfe:face:b00c::3", 0, "::"),
 };
 
 static const vector<MaskBoundaryData> maskBoundaryProvider = {
@@ -1369,31 +1407,40 @@ static const vector<MaskBoundaryData> maskBoundaryProvider = {
     MaskBoundaryData("2620:0:1cfe:face:b00c::1", 48, "2620:0:1cfc::", false),
 };
 
-INSTANTIATE_TEST_CASE_P(IPAddress,
+INSTANTIATE_TEST_CASE_P(
+    IPAddress,
     IPAddressTest,
     ::testing::ValuesIn(validAddressProvider));
-INSTANTIATE_TEST_CASE_P(IPAddress,
+INSTANTIATE_TEST_CASE_P(
+    IPAddress,
     IPAddressFlagTest,
     ::testing::ValuesIn(flagProvider));
-INSTANTIATE_TEST_CASE_P(IPAddress,
+INSTANTIATE_TEST_CASE_P(
+    IPAddress,
     IPAddressMappedTest,
     ::testing::ValuesIn(mapProvider));
-INSTANTIATE_TEST_CASE_P(IPAddress,
+INSTANTIATE_TEST_CASE_P(
+    IPAddress,
     IPAddressCtorTest,
     ::testing::ValuesIn(invalidAddressProvider));
-INSTANTIATE_TEST_CASE_P(IPAddress,
+INSTANTIATE_TEST_CASE_P(
+    IPAddress,
     IPAddressCtorBinaryTest,
     ::testing::ValuesIn(invalidBinaryProvider));
-INSTANTIATE_TEST_CASE_P(IPAddress,
+INSTANTIATE_TEST_CASE_P(
+    IPAddress,
     IPAddressMaskTest,
     ::testing::ValuesIn(masksProvider));
-INSTANTIATE_TEST_CASE_P(IPAddress,
+INSTANTIATE_TEST_CASE_P(
+    IPAddress,
     IPAddressMaskBoundaryTest,
     ::testing::ValuesIn(maskBoundaryProvider));
-INSTANTIATE_TEST_CASE_P(IPAddress,
+INSTANTIATE_TEST_CASE_P(
+    IPAddress,
     IPAddressByteAccessorTest,
     ::testing::ValuesIn(validAddressProvider));
-INSTANTIATE_TEST_CASE_P(IPAddress,
+INSTANTIATE_TEST_CASE_P(
+    IPAddress,
     IPAddressBitAccessorTest,
     ::testing::ValuesIn(validAddressProvider));
 
@@ -1420,63 +1467,55 @@ TEST(IPAddressV4, fetchMask) {
 }
 
 TEST(IPAddressV6, fetchMask) {
-  using ByteArray8 = std::array<uint8_t, 8>;
-
   struct X : private IPAddressV6 {
     using IPAddressV6::fetchMask;
   };
 
-  auto join = [](std::array<ByteArray8, 2> parts) {
-    ByteArray16 _return;
-    std::memcpy(_return.data(), parts.data(), _return.size());
-    return _return;
-  };
-
   EXPECT_THAT(
       X::fetchMask(0),
-      ::testing::ElementsAreArray(join({{
+      ::testing::ElementsAreArray(join8({{
           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
       }})));
 
   EXPECT_THAT(
       X::fetchMask(1),
-      ::testing::ElementsAreArray(join({{
+      ::testing::ElementsAreArray(join8({{
           ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
       }})));
 
   EXPECT_THAT(
       X::fetchMask(63),
-      ::testing::ElementsAreArray(join({{
+      ::testing::ElementsAreArray(join8({{
           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
       }})));
 
   EXPECT_THAT(
       X::fetchMask(64),
-      ::testing::ElementsAreArray(join({{
+      ::testing::ElementsAreArray(join8({{
           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
           ByteArray8{{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
       }})));
 
   EXPECT_THAT(
       X::fetchMask(65),
-      ::testing::ElementsAreArray(join({{
+      ::testing::ElementsAreArray(join8({{
           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
           ByteArray8{{0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}},
       }})));
 
   EXPECT_THAT(
       X::fetchMask(127),
-      ::testing::ElementsAreArray(join({{
+      ::testing::ElementsAreArray(join8({{
           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe}},
       }})));
 
   EXPECT_THAT(
       X::fetchMask(128),
-      ::testing::ElementsAreArray(join({{
+      ::testing::ElementsAreArray(join8({{
           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
           ByteArray8{{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}},
       }})));

folly/test/MacAddressTest.cpp

@@ -94,8 +94,8 @@ TEST(MacAddress, fromBinary) {
 }
 
 TEST(MacAddress, toString) {
-  EXPECT_EQ("12:34:56:78:9a:bc",
-            MacAddress::fromHBO(0x123456789abc).toString());
+  EXPECT_EQ(
+      "12:34:56:78:9a:bc", MacAddress::fromHBO(0x123456789abc).toString());
   EXPECT_EQ("12:34:56:78:9a:bc", MacAddress("12:34:56:78:9a:bc").toString());
   EXPECT_EQ("01:23:45:67:89:ab", MacAddress("01-23-45-67-89-ab").toString());
   EXPECT_EQ("01:23:45:67:89:ab", MacAddress("0123456789ab").toString());
@@ -131,9 +131,11 @@ TEST(MacAddress, attributes) {
 }
 
 TEST(MacAddress, createMulticast) {
-  EXPECT_EQ(MacAddress("33:33:00:01:00:03"),
+  EXPECT_EQ(
+      MacAddress("33:33:00:01:00:03"),
       MacAddress::createMulticast(IPAddressV6("ff02:dead:beef::1:3")));
-  EXPECT_EQ(MacAddress("33:33:12:34:56:78"),
+  EXPECT_EQ(
+      MacAddress("33:33:12:34:56:78"),
       MacAddress::createMulticast(IPAddressV6("ff02::abcd:1234:5678")));
 }
 

folly/test/SocketAddressTest.cpp

@@ -20,6 +20,8 @@
 #include <sstream>
 #include <system_error>
 
+#include <folly/Array.h>
+#include <folly/String.h>
 #include <folly/experimental/TestUtil.h>
 #include <folly/portability/GTest.h>
 #include <folly/portability/Sockets.h>
@@ -66,12 +68,9 @@ TEST(SocketAddress, IPv4ToStringConversion) {
   SocketAddress addr;
   for (int pos = 0; pos < 4; ++pos) {
     for (int i = 0; i < 256; ++i) {
-      int fragments[] = {5,5,5,5};
+      auto fragments = folly::make_array(5, 5, 5, 5);
       fragments[pos] = i;
-      std::ostringstream ss;
-      ss << fragments[0] << "." << fragments[1] << "."
-         << fragments[2] << "." << fragments[3];
-      string ipString = ss.str();
+      auto ipString = folly::join(".", fragments);
       addr.setFromIpPort(ipString, 1234);
       EXPECT_EQ(addr.getAddressStr(), ipString);
     }
@@ -118,8 +117,7 @@ TEST(SocketAddress, SetFromInvalidIpv4) {
   // Try setting to an invalid value
   // Since setFromIpPort() shouldn't allow hostname lookups, setting to
   // "localhost" should fail, even if localhost is resolvable
-  EXPECT_THROW(addr.setFromIpPort("localhost", 1234),
-               std::runtime_error);
+  EXPECT_THROW(addr.setFromIpPort("localhost", 1234), std::runtime_error);
 
   // Make sure the address still has the old contents
   EXPECT_EQ(addr.getFamily(), AF_INET);
@@ -416,8 +414,10 @@ TEST(SocketAddress, IsLoopback) {
   EXPECT_TRUE(addr.isLoopbackAddress());
 }
 
-void CheckPrefixMatch(const SocketAddress& first,
-    const SocketAddress& second, unsigned matchingPrefixLen) {
+void CheckPrefixMatch(
+    const SocketAddress& first,
+    const SocketAddress& second,
+    unsigned matchingPrefixLen) {
   unsigned i;
   for (i = 0; i <= matchingPrefixLen; i++) {
     EXPECT_TRUE(first.prefixMatch(second, i));
@@ -468,7 +468,7 @@ TEST(SocketAddress, CheckComparatorBehavior) {
   // The following comparison are strict (so if first and second were
   // inverted that is ok.
 
-  //IP V4
+  // IP V4
 
   // port comparisions
   first.setFromIpPort("128.0.0.0", 0);
@@ -669,14 +669,15 @@ TEST(SocketAddress, AnonymousUnix) {
     ADD_FAILURE();                                                 \
   }
 
-void testSetFromSocket(const SocketAddress *serverBindAddr,
-                       const SocketAddress *clientBindAddr,
-                       SocketAddress *listenAddrRet,
-                       SocketAddress *acceptAddrRet,
-                       SocketAddress *serverAddrRet,
-                       SocketAddress *serverPeerAddrRet,
-                       SocketAddress *clientAddrRet,
-                       SocketAddress *clientPeerAddrRet) {
+void testSetFromSocket(
+    const SocketAddress* serverBindAddr,
+    const SocketAddress* clientBindAddr,
+    SocketAddress* listenAddrRet,
+    SocketAddress* acceptAddrRet,
+    SocketAddress* serverAddrRet,
+    SocketAddress* serverPeerAddrRet,
+    SocketAddress* clientAddrRet,
+    SocketAddress* clientPeerAddrRet) {
   int listenSock = fsp::socket(serverBindAddr->getFamily(), SOCK_STREAM, 0);
   REQUIRE_ERRNO(listenSock > 0, "failed to create listen socket");
   sockaddr_storage laddr;
@@ -690,8 +691,8 @@ void testSetFromSocket(const SocketAddress *serverBindAddr,
   listenAddrRet->setFromLocalAddress(listenSock);
 
   SocketAddress listenPeerAddr;
-  EXPECT_THROW(listenPeerAddr.setFromPeerAddress(listenSock),
-               std::runtime_error);
+  EXPECT_THROW(
+      listenPeerAddr.setFromPeerAddress(listenSock), std::runtime_error);
 
   // Note that we use the family from serverBindAddr here, since we allow
   // clientBindAddr to be nullptr.
@@ -701,21 +702,25 @@ void testSetFromSocket(const SocketAddress *serverBindAddr,
     sockaddr_storage clientAddr;
     clientBindAddr->getAddress(&clientAddr);
 
-    rc = bind(clientSock, reinterpret_cast<sockaddr*>(&clientAddr),
+    rc = bind(
+        clientSock,
+        reinterpret_cast<sockaddr*>(&clientAddr),
         clientBindAddr->getActualSize());
     REQUIRE_ERRNO(rc == 0, "failed to bind to client socket");
   }
 
   sockaddr_storage listenAddr;
   listenAddrRet->getAddress(&listenAddr);
-  rc = connect(clientSock, reinterpret_cast<sockaddr*>(&listenAddr),
+  rc = connect(
+      clientSock,
+      reinterpret_cast<sockaddr*>(&listenAddr),
       listenAddrRet->getActualSize());
   REQUIRE_ERRNO(rc == 0, "failed to connect");
 
   sockaddr_storage acceptAddr;
   socklen_t acceptAddrLen = sizeof(acceptAddr);
-  int serverSock = accept(listenSock,
-      reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
+  int serverSock = accept(
+      listenSock, reinterpret_cast<sockaddr*>(&acceptAddr), &acceptAddrLen);
   REQUIRE_ERRNO(serverSock > 0, "failed to accept");
   acceptAddrRet->setFromSockaddr(
       reinterpret_cast<sockaddr*>(&acceptAddr), acceptAddrLen);
@@ -740,10 +745,15 @@ TEST(SocketAddress, SetFromSocketIPv4) {
   SocketAddress clientAddr;
   SocketAddress clientPeerAddr;
 
-  testSetFromSocket(&serverBindAddr, &clientBindAddr,
-                    &listenAddr, &acceptAddr,
-                    &serverAddr, &serverPeerAddr,
-                    &clientAddr, &clientPeerAddr);
+  testSetFromSocket(
+      &serverBindAddr,
+      &clientBindAddr,
+      &listenAddr,
+      &acceptAddr,
+      &serverAddr,
+      &serverPeerAddr,
+      &clientAddr,
+      &clientPeerAddr);
 
   // The server socket's local address should have the same port as the listen
   // address.  The IP will be different, since the listening socket is
@@ -781,10 +791,15 @@ TEST(SocketAddress, SetFromSocketUnixAbstract) {
   SocketAddress clientAddr;
   SocketAddress clientPeerAddr;
 
-  testSetFromSocket(&serverBindAddr, &clientBindAddr,
-                    &listenAddr, &acceptAddr,
-                    &serverAddr, &serverPeerAddr,
-                    &clientAddr, &clientPeerAddr);
+  testSetFromSocket(
+      &serverBindAddr,
+      &clientBindAddr,
+      &listenAddr,
+      &acceptAddr,
+      &serverAddr,
+      &serverPeerAddr,
+      &clientAddr,
+      &clientPeerAddr);
 
   // The server socket's local address should be the same as the listen
   // address.
@@ -820,10 +835,15 @@ TEST(SocketAddress, SetFromSocketUnixExplicit) {
     serverBindAddr.setFromPath(serverPath.c_str());
     clientBindAddr.setFromPath(clientPath.c_str());
 
-    testSetFromSocket(&serverBindAddr, &clientBindAddr,
-                      &listenAddr, &acceptAddr,
-                      &serverAddr, &serverPeerAddr,
-                      &clientAddr, &clientPeerAddr);
+    testSetFromSocket(
+        &serverBindAddr,
+        &clientBindAddr,
+        &listenAddr,
+        &acceptAddr,
+        &serverAddr,
+        &serverPeerAddr,
+        &clientAddr,
+        &clientPeerAddr);
   } catch (...) {
     // Remove the socket files after we are done
     unlink(serverPath.c_str());
@@ -861,10 +881,15 @@ TEST(SocketAddress, SetFromSocketUnixAnonymous) {
   try {
     serverBindAddr.setFromPath(serverPath.c_str());
 
-    testSetFromSocket(&serverBindAddr, nullptr,
-                      &listenAddr, &acceptAddr,
-                      &serverAddr, &serverPeerAddr,
-                      &clientAddr, &clientPeerAddr);
+    testSetFromSocket(
+        &serverBindAddr,
+        nullptr,
+        &listenAddr,
+        &acceptAddr,
+        &serverAddr,
+        &serverPeerAddr,
+        &clientAddr,
+        &clientPeerAddr);
   } catch (...) {
     // Remove the socket file after we are done
     unlink(serverPath.c_str());

folly/test/SocketAddressTestHelper.cpp

@@ -47,5 +47,4 @@ bool SocketAddressTestHelper::isFamilyOfAddrEnabled(const char* addr) {
   freeaddrinfo(resultsp);
   return !err;
 }
-
 }

folly/test/SocketAddressTestHelper.h

@@ -20,7 +20,6 @@ namespace folly {
 
 class SocketAddressTestHelper {
  public:
-
   static constexpr const char* kLoopbackAddrIPv4 = "127.0.0.1";
   static constexpr const char* kLoopbackAddrIPv6 = "::1";
 
@@ -40,8 +39,6 @@ class SocketAddressTestHelper {
   static bool isIPv6Enabled();
 
  private:
-
   static bool isFamilyOfAddrEnabled(const char* addr);
 };
-
 }