diff --git a/test/meson.build b/test/meson.build
index b501080..62ca28b 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -51,6 +51,7 @@
   'netlink',
   'network_manager',
   #'rtnetlink',
+  'types',
   'util',
   'vlan_interface',
 ]
diff --git a/test/test_ethernet_interface.cpp b/test/test_ethernet_interface.cpp
index f8254b0..ace2b1d 100644
--- a/test/test_ethernet_interface.cpp
+++ b/test/test_ethernet_interface.cpp
@@ -117,7 +117,7 @@
                                "/xyz/openbmc_test/network"sv, config::Parser());
 
     EXPECT_EQ(mtu, intf.mtu());
-    EXPECT_EQ(mac_address::toString(mac), intf.macAddress());
+    EXPECT_EQ(std::to_string(mac), intf.macAddress());
     EXPECT_TRUE(intf.linkUp());
 }
 
diff --git a/test/test_ipaddress.cpp b/test/test_ipaddress.cpp
index f5a6147..9747cf9 100644
--- a/test/test_ipaddress.cpp
+++ b/test/test_ipaddress.cpp
@@ -7,7 +7,6 @@
 
 #include <cstring>
 #include <stdexcept>
-#include <stdplus/raw.hpp>
 #include <string>
 #include <vector>
 
@@ -126,8 +125,7 @@
     EXPECT_EQ(msg.ifa_index, addresses[0].interface);
     EXPECT_EQ(msg.ifa_scope, addresses[0].scope);
     EXPECT_EQ(msg.ifa_prefixlen, addresses[0].prefix);
-    EXPECT_TRUE(
-        stdplus::raw::equal(addr, std::get<in_addr>(addresses[0].address)));
+    EXPECT_EQ(addr, addresses[0].address);
 }
 
 TEST(ParseNeighbor, FilterScope)
@@ -164,8 +162,7 @@
     EXPECT_EQ(msg.ifa_index, addresses[0].interface);
     EXPECT_EQ(msg.ifa_scope, addresses[0].scope);
     EXPECT_EQ(msg.ifa_prefixlen, addresses[0].prefix);
-    EXPECT_TRUE(
-        stdplus::raw::equal(addr, std::get<in_addr>(addresses[0].address)));
+    EXPECT_EQ(addr, addresses[0].address);
 }
 
 TEST(ParseNeighbor, NoFilter)
@@ -198,8 +195,7 @@
     EXPECT_EQ(msg.ifa_index, addresses[0].interface);
     EXPECT_EQ(msg.ifa_scope, addresses[0].scope);
     EXPECT_EQ(msg.ifa_prefixlen, addresses[0].prefix);
-    EXPECT_TRUE(
-        stdplus::raw::equal(addr, std::get<in6_addr>(addresses[0].address)));
+    EXPECT_EQ(addr, addresses[0].address);
 }
 
 } // namespace detail
diff --git a/test/test_neighbor.cpp b/test/test_neighbor.cpp
index 0f0abc4..3cdb209 100644
--- a/test/test_neighbor.cpp
+++ b/test/test_neighbor.cpp
@@ -8,7 +8,6 @@
 
 #include <cstring>
 #include <stdexcept>
-#include <stdplus/raw.hpp>
 #include <string>
 #include <vector>
 
@@ -118,8 +117,7 @@
     EXPECT_EQ(msg.ndm_ifindex, neighbors[0].interface);
     EXPECT_EQ(msg.ndm_state, neighbors[0].state);
     EXPECT_FALSE(neighbors[0].mac);
-    EXPECT_TRUE(
-        stdplus::raw::equal(addr, std::get<in_addr>(neighbors[0].address)));
+    EXPECT_EQ(addr, neighbors[0].address);
 }
 
 TEST(ParseNeighbor, FilterInterface)
@@ -155,8 +153,7 @@
     EXPECT_EQ(msg.ndm_ifindex, neighbors[0].interface);
     EXPECT_EQ(msg.ndm_state, neighbors[0].state);
     EXPECT_FALSE(neighbors[0].mac);
-    EXPECT_TRUE(
-        stdplus::raw::equal(addr, std::get<in_addr>(neighbors[0].address)));
+    EXPECT_EQ(addr, neighbors[0].address);
 }
 
 TEST(ParseNeighbor, FilterState)
@@ -192,8 +189,7 @@
     EXPECT_EQ(msg.ndm_ifindex, neighbors[0].interface);
     EXPECT_EQ(msg.ndm_state, neighbors[0].state);
     EXPECT_FALSE(neighbors[0].mac);
-    EXPECT_TRUE(
-        stdplus::raw::equal(addr, std::get<in_addr>(neighbors[0].address)));
+    EXPECT_EQ(addr, neighbors[0].address);
 }
 
 TEST(ParseNeighbor, Full)
@@ -234,10 +230,8 @@
     EXPECT_EQ(1, neighbors.size());
     EXPECT_EQ(msg.ndm_ifindex, neighbors[0].interface);
     EXPECT_EQ(msg.ndm_state, neighbors[0].state);
-    EXPECT_TRUE(neighbors[0].mac);
-    EXPECT_TRUE(stdplus::raw::equal(mac, *neighbors[0].mac));
-    EXPECT_TRUE(
-        stdplus::raw::equal(addr, std::get<in6_addr>(neighbors[0].address)));
+    EXPECT_EQ(mac, neighbors[0].mac);
+    EXPECT_EQ(addr, neighbors[0].address);
 }
 
 } // namespace detail
diff --git a/test/test_types.cpp b/test/test_types.cpp
new file mode 100644
index 0000000..1f34144
--- /dev/null
+++ b/test/test_types.cpp
@@ -0,0 +1,133 @@
+#include "types.hpp"
+
+#include <arpa/inet.h>
+#include <fmt/chrono.h>
+#include <fmt/format.h>
+
+#include <sstream>
+#include <string_view>
+
+#include <gtest/gtest.h>
+
+using std::literals::string_view_literals::operator""sv;
+
+TEST(EqualOperator, EthAddr)
+{
+    EXPECT_EQ((ether_addr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66}),
+              (ether_addr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66}));
+    EXPECT_EQ((ether_addr{}), (ether_addr{}));
+    EXPECT_NE((ether_addr{1}), (ether_addr{}));
+}
+
+TEST(EqualOperator, InAddr)
+{
+    EXPECT_EQ((in_addr{0xff00ff00}), (in_addr{0xff00ff00}));
+    EXPECT_EQ((in_addr{}), (in_addr{}));
+    EXPECT_NE((in_addr{1}), (in_addr{}));
+}
+
+TEST(EqualOperator, In6Addr)
+{
+    EXPECT_EQ((in6_addr{0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff}),
+              (in6_addr{0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff}));
+    EXPECT_EQ((in6_addr{}), (in6_addr{}));
+    EXPECT_NE((in6_addr{1}), (in6_addr{}));
+}
+
+namespace phosphor::network
+{
+
+TEST(EqualOperator, InAddrAny)
+{
+    EXPECT_EQ(InAddrAny(in6_addr{0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                 0xff}),
+              (in6_addr{0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff}));
+    EXPECT_NE(InAddrAny(in6_addr{0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+                                 0xff}),
+              (in_addr{}));
+    EXPECT_EQ((in6_addr{}), InAddrAny(in6_addr{}));
+    EXPECT_NE((in_addr{}), InAddrAny(in6_addr{}));
+    EXPECT_NE(InAddrAny(in6_addr{1}), InAddrAny(in6_addr{}));
+}
+
+namespace detail
+{
+
+TEST(BufMaker, EthAddr)
+{
+    AddrBufMaker<ether_addr> abm;
+    EXPECT_EQ("11:22:33:44:55:66"sv,
+              abm(ether_addr{0x11, 0x22, 0x33, 0x44, 0x55, 0x66}));
+    EXPECT_EQ("01:02:03:04:05:67"sv,
+              abm(ether_addr{0x01, 0x02, 0x03, 0x04, 0x05, 0x67}));
+    EXPECT_EQ("00:00:00:00:00:00"sv,
+              abm(ether_addr{0x00, 0x00, 0x00, 0x00, 0x00, 0x00}));
+}
+
+TEST(BufMaker, InAddr)
+{
+    AddrBufMaker<in_addr> abm;
+    EXPECT_EQ("255.255.255.255"sv, abm(in_addr{0xffffffff}));
+    EXPECT_EQ("1.15.3.4"sv, abm(in_addr{htonl(0x010f0304)}));
+    EXPECT_EQ("0.0.0.0"sv, abm(in_addr{}));
+}
+
+TEST(BufMaker, In6Addr)
+{
+    AddrBufMaker<in6_addr> abm;
+    EXPECT_EQ("::"sv, abm(in6_addr{}));
+    EXPECT_EQ("ff::"sv, abm(in6_addr{0, 0xff}));
+    EXPECT_EQ("::ff"sv,
+              abm(in6_addr{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff}));
+    EXPECT_EQ("0:0:ff::ff"sv, abm(in6_addr{0, 0, 0, 0, 0, 0xff, 0, 0, 0, 0, 0,
+                                           0, 0, 0, 0, 0xff}));
+    EXPECT_EQ("::100:0:ff"sv,
+              abm(in6_addr{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0xff}));
+    EXPECT_EQ("ff00::"sv, abm(in6_addr{0xff}));
+    EXPECT_EQ("1:2:3:4:5:6:7:8"sv,
+              abm(in6_addr{0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8}));
+}
+
+TEST(BasicOps, AllAddrs)
+{
+    EXPECT_NE(InAddrAny{in6_addr{}}, InAddrAny{in_addr{}});
+
+    EXPECT_EQ("a 01:00:00:00:00:00", fmt::format("a {}", ether_addr{1}));
+    EXPECT_EQ("a 0.0.0.1", fmt::format("a {}", in_addr{htonl(1)}));
+    EXPECT_EQ("a 0.0.0.1", fmt::format("a {}", InAddrAny{in_addr{htonl(1)}}));
+    EXPECT_EQ("a 100::", fmt::format("a {}", in6_addr{1}));
+    EXPECT_EQ("a 100::", fmt::format("a {}", InAddrAny{in6_addr{1}}));
+
+    EXPECT_EQ("01:00:00:00:00:00", std::to_string(ether_addr{1}));
+    EXPECT_EQ("0.0.0.1", std::to_string(in_addr{htonl(1)}));
+    EXPECT_EQ("0.0.0.1", std::to_string(InAddrAny{in_addr{htonl(1)}}));
+    EXPECT_EQ("100::", std::to_string(in6_addr{1}));
+    EXPECT_EQ("100::", std::to_string(InAddrAny{in6_addr{1}}));
+
+    EXPECT_EQ("a01:00:00:00:00:00",
+              (std::stringstream{} << "a" << ether_addr{1}).str());
+    EXPECT_EQ("a0.0.0.1",
+              (std::stringstream{} << "a" << in_addr{htonl(1)}).str());
+    EXPECT_EQ(
+        "a0.0.0.1",
+        (std::stringstream{} << "a" << InAddrAny{in_addr{htonl(1)}}).str());
+    EXPECT_EQ("a100::", (std::stringstream{} << "a" << in6_addr{1}).str());
+    EXPECT_EQ("a100::",
+              (std::stringstream{} << "a" << InAddrAny{in6_addr{1}}).str());
+}
+
+TEST(Perf, In6Addr)
+{
+    GTEST_SKIP();
+    auto start = std::chrono::steady_clock::now();
+    for (size_t i = 0; i < 10000000; ++i)
+    {
+        AddrBufMaker<in6_addr>{}(in6_addr{1});
+    }
+    fmt::print("Duration: {}\n", std::chrono::steady_clock::now() - start);
+    // Make sure this test isn't enabled
+    EXPECT_FALSE(true);
+}
+
+} // namespace detail
+} // namespace phosphor::network
diff --git a/test/test_util.cpp b/test/test_util.cpp
index cfbab77..39f5c39 100644
--- a/test/test_util.cpp
+++ b/test/test_util.cpp
@@ -1,12 +1,13 @@
 #include "util.hpp"
 
 #include <arpa/inet.h>
+#include <fmt/chrono.h>
 #include <netinet/in.h>
 
+#include <charconv>
 #include <cstddef>
 #include <cstring>
 #include <stdexcept>
-#include <stdplus/raw.hpp>
 #include <string>
 #include <string_view>
 #include <xyz/openbmc_project/Common/error.hpp>
@@ -55,19 +56,6 @@
     EXPECT_THROW(addrFromBuf(AF_UNSPEC, buf2), std::invalid_argument);
 }
 
-TEST_F(TestUtil, IpToString)
-{
-    struct in_addr ip1;
-    EXPECT_EQ(1, inet_pton(AF_INET, "192.168.10.1", &ip1));
-    EXPECT_EQ("192.168.10.1", toString(ip1));
-    EXPECT_EQ("192.168.10.1", toString(InAddrAny(ip1)));
-
-    struct in6_addr ip2;
-    EXPECT_EQ(1, inet_pton(AF_INET6, "fdd8:b5ad:9d93:94ee::2:1", &ip2));
-    EXPECT_EQ("fdd8:b5ad:9d93:94ee::2:1", toString(ip2));
-    EXPECT_EQ("fdd8:b5ad:9d93:94ee::2:1", toString(InAddrAny(ip2)));
-}
-
 TEST_F(TestUtil, IpValidation)
 {
     EXPECT_TRUE(isValidIP(AF_INET, "0.0.0.0"));
@@ -152,30 +140,15 @@
 
 TEST(MacFromString, Valid)
 {
-    EXPECT_TRUE(
-        stdplus::raw::equal(ether_addr{}, fromString("00:00:00:00:00:00")));
-    EXPECT_TRUE(
-        stdplus::raw::equal(ether_addr{0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa},
-                            fromString("FF:EE:DD:cc:bb:aa")));
-    EXPECT_TRUE(
-        stdplus::raw::equal(ether_addr{0x00, 0x01, 0x02, 0x03, 0x04, 0x05},
-                            fromString("0:1:2:3:4:5")));
-    EXPECT_TRUE(
-        stdplus::raw::equal(ether_addr{0x01, 0x23, 0x45, 0x67, 0x89, 0xab},
-                            fromString("0123456789AB")));
-    EXPECT_TRUE(
-        stdplus::raw::equal(ether_addr{0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa},
-                            fromString("FFEEDDccbbaa")));
-}
-
-TEST(MacToString, Valid)
-{
-    EXPECT_EQ("11:22:33:44:55:66",
-              toString({0x11, 0x22, 0x33, 0x44, 0x55, 0x66}));
-    EXPECT_EQ("01:02:03:04:05:67",
-              toString({0x01, 0x02, 0x03, 0x04, 0x05, 0x67}));
-    EXPECT_EQ("00:00:00:00:00:00",
-              toString({0x00, 0x00, 0x00, 0x00, 0x00, 0x00}));
+    EXPECT_EQ((ether_addr{}), fromString("00:00:00:00:00:00"));
+    EXPECT_EQ((ether_addr{0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa}),
+              fromString("FF:EE:DD:cc:bb:aa"));
+    EXPECT_EQ((ether_addr{0x00, 0x01, 0x02, 0x03, 0x04, 0x05}),
+              fromString("0:1:2:3:4:5"));
+    EXPECT_EQ((ether_addr{0x01, 0x23, 0x45, 0x67, 0x89, 0xab}),
+              fromString("0123456789AB"));
+    EXPECT_EQ((ether_addr{0xff, 0xee, 0xdd, 0xcc, 0xbb, 0xaa}),
+              fromString("FFEEDDccbbaa"));
 }
 
 TEST(MacIsEmpty, True)