Use std::string_view and fmtlib across all libraries (#3402)

- Twine, StringRef, Format, and NativeFormatting have been removed - Logging now uses fmtlib style formatting - Nearly all uses of wpi::outs/errs have been replaced with fmt::print() or std::puts()/std::fputs() (for unformatted strings). - A wpi/fmt/raw_ostream.h header has been added to enable fmt::print() with wpi::raw_ostream
2026-06-20 00:51:42 +00:00 · 2021-06-06 16:13:58 -07:00
parent 4f1cecb8e7
commit b2c3b2dd8e
441 changed files with 5061 additions and 9749 deletions
--- a/ntcore/src/test/native/cpp/EntryNotifierTest.cpp
+++ b/ntcore/src/test/native/cpp/EntryNotifierTest.cpp
@@ -3,6 +3,7 @@
 // the WPILib BSD license file in the root directory of this project.

 #include <wpi/Logger.h>
+#include <wpi/StringExtras.h>

 #include "EntryNotifier.h"
 #include "TestPrinters.h"
@@ -245,7 +246,7 @@ TEST_F(EntryNotifierTest, PollPrefixBasic) {
  int g4count = 0;
  for (const auto& result : results) {
    SCOPED_TRACE(::testing::PrintToString(result));
-    EXPECT_TRUE(wpi::StringRef(result.name).startswith("/foo"));
+    EXPECT_TRUE(wpi::starts_with(result.name, "/foo"));
    EXPECT_THAT(result.value, ValueEq(Value::MakeDouble(1)));
    EXPECT_EQ(Handle{result.entry}.GetType(), Handle::kEntry);
    EXPECT_EQ(Handle{result.entry}.GetInst(), 1);
--- a/ntcore/src/test/native/cpp/MockEntryNotifier.h
+++ b/ntcore/src/test/native/cpp/MockEntryNotifier.h
@@ -18,19 +18,19 @@ class MockEntryNotifier : public IEntryNotifier {
  MOCK_METHOD3(
      Add,
      unsigned int(std::function<void(const EntryNotification& event)> callback,
-                   wpi::StringRef prefix, unsigned int flags));
+                   std::string_view prefix, unsigned int flags));
  MOCK_METHOD3(
      Add,
      unsigned int(std::function<void(const EntryNotification& event)> callback,
                   unsigned int local_id, unsigned int flags));
  MOCK_METHOD3(AddPolled,
-               unsigned int(unsigned int poller_uid, wpi::StringRef prefix,
+               unsigned int(unsigned int poller_uid, std::string_view prefix,
                            unsigned int flags));
  MOCK_METHOD3(AddPolled,
               unsigned int(unsigned int poller_uid, unsigned int local_id,
                            unsigned int flags));
  MOCK_METHOD5(NotifyEntry,
-               void(unsigned int local_id, wpi::StringRef name,
+               void(unsigned int local_id, std::string_view name,
                    std::shared_ptr<Value> value, unsigned int flags,
                    unsigned int only_listener));
 };
--- a/ntcore/src/test/native/cpp/MockRpcServer.h
+++ b/ntcore/src/test/native/cpp/MockRpcServer.h
@@ -16,7 +16,7 @@ class MockRpcServer : public IRpcServer {
  MOCK_METHOD1(RemoveRpc, void(unsigned int rpc_uid));
  MOCK_METHOD7(ProcessRpc,
               void(unsigned int local_id, unsigned int call_uid,
-                    wpi::StringRef name, wpi::StringRef params,
+                    std::string_view name, std::string_view params,
                    const ConnectionInfo& conn, SendResponseFunc send_response,
                    unsigned int rpc_uid));
 };
--- a/ntcore/src/test/native/cpp/StorageTest.cpp
+++ b/ntcore/src/test/native/cpp/StorageTest.cpp
@@ -4,6 +4,8 @@

 #include "StorageTest.h"

+#include <wpi/SmallString.h>
+#include <wpi/StringExtras.h>
 #include <wpi/raw_istream.h>
 #include <wpi/raw_ostream.h>

@@ -19,7 +21,6 @@ using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::IsNull;
 using ::testing::Return;
-using wpi::StringRef;

 namespace nt {

@@ -86,13 +87,13 @@ class StorageTestPersistent : public StorageTestEmpty {
    storage.SetEntryTypeValue("double/big", Value::MakeDouble(1.3e8));
    storage.SetEntryTypeValue("string/empty", Value::MakeString(""));
    storage.SetEntryTypeValue("string/normal", Value::MakeString("hello"));
-    storage.SetEntryTypeValue("string/special",
-                              Value::MakeString(StringRef("\0\3\5\n", 4)));
+    storage.SetEntryTypeValue(
+        "string/special", Value::MakeString(std::string_view("\0\3\5\n", 4)));
    storage.SetEntryTypeValue("string/quoted", Value::MakeString("\"a\""));
    storage.SetEntryTypeValue("raw/empty", Value::MakeRaw(""));
    storage.SetEntryTypeValue("raw/normal", Value::MakeRaw("hello"));
    storage.SetEntryTypeValue("raw/special",
-                              Value::MakeRaw(StringRef("\0\3\5\n", 4)));
+                              Value::MakeRaw(std::string_view("\0\3\5\n", 4)));
    storage.SetEntryTypeValue("booleanarr/empty",
                              Value::MakeBooleanArray(std::vector<int>{}));
    storage.SetEntryTypeValue("booleanarr/one",
@@ -114,7 +115,7 @@ class StorageTestPersistent : public StorageTestEmpty {
    storage.SetEntryTypeValue(
        "stringarr/two",
        Value::MakeStringArray(std::vector<std::string>{"hello", "world\n"}));
-    storage.SetEntryTypeValue(StringRef("\0\3\5\n", 4),
+    storage.SetEntryTypeValue(std::string_view("\0\3\5\n", 4),
                              Value::MakeBoolean(true));
    storage.SetEntryTypeValue("=", Value::MakeBoolean(true));
    ::testing::Mock::VerifyAndClearExpectations(&dispatcher);
@@ -127,7 +128,7 @@ class StorageTestPersistent : public StorageTestEmpty {

 class MockLoadWarn {
 public:
-  MOCK_METHOD2(Warn, void(size_t line, wpi::StringRef msg));
+  MOCK_METHOD2(Warn, void(size_t line, std::string_view msg));
 };

 TEST_P(StorageTestEmpty, Construct) {
@@ -166,7 +167,7 @@ TEST_P(StorageTestEmpty, SetEntryTypeValueAssignNew) {
              QueueOutgoing(MessageEq(Message::EntryAssign(
                                "foo", GetParam() ? 0 : 0xffff, 1, value, 0)),
                            IsNull(), IsNull()));
-  EXPECT_CALL(notifier, NotifyEntry(0, StringRef("foo"), value,
+  EXPECT_CALL(notifier, NotifyEntry(0, std::string_view("foo"), value,
                                    NT_NOTIFY_NEW | NT_NOTIFY_LOCAL, UINT_MAX));

  storage.SetEntryTypeValue("foo", value);
@@ -189,7 +190,7 @@ TEST_P(StorageTestPopulateOne, SetEntryTypeValueAssignTypeChange) {
                                "foo", GetParam() ? 0 : 0xffff, 2, value, 0)),
                            IsNull(), IsNull()));
  EXPECT_CALL(notifier,
-              NotifyEntry(0, StringRef("foo"), value,
+              NotifyEntry(0, std::string_view("foo"), value,
                          NT_NOTIFY_UPDATE | NT_NOTIFY_LOCAL, UINT_MAX));

  storage.SetEntryTypeValue("foo", value);
@@ -216,7 +217,7 @@ TEST_P(StorageTestPopulated, SetEntryTypeValueDifferentValue) {
                              IsNull(), IsNull()));
  }
  EXPECT_CALL(notifier,
-              NotifyEntry(1, StringRef("foo2"), value,
+              NotifyEntry(1, std::string_view("foo2"), value,
                          NT_NOTIFY_UPDATE | NT_NOTIFY_LOCAL, UINT_MAX));
  storage.SetEntryTypeValue("foo2", value);
  EXPECT_EQ(value, GetEntry("foo2")->value);
@@ -249,7 +250,7 @@ TEST_P(StorageTestEmpty, SetEntryValueAssignNew) {
              QueueOutgoing(MessageEq(Message::EntryAssign(
                                "foo", GetParam() ? 0 : 0xffff, 1, value, 0)),
                            IsNull(), IsNull()));
-  EXPECT_CALL(notifier, NotifyEntry(0, StringRef("foo"), value,
+  EXPECT_CALL(notifier, NotifyEntry(0, std::string_view("foo"), value,
                                    NT_NOTIFY_NEW | NT_NOTIFY_LOCAL, UINT_MAX));

  EXPECT_TRUE(storage.SetEntryValue("foo", value));
@@ -285,7 +286,7 @@ TEST_P(StorageTestPopulated, SetEntryValueDifferentValue) {
                              IsNull(), IsNull()));
  }
  EXPECT_CALL(notifier,
-              NotifyEntry(1, StringRef("foo2"), value,
+              NotifyEntry(1, std::string_view("foo2"), value,
                          NT_NOTIFY_UPDATE | NT_NOTIFY_LOCAL, UINT_MAX));

  EXPECT_TRUE(storage.SetEntryValue("foo2", value));
@@ -320,7 +321,7 @@ TEST_P(StorageTestEmpty, SetDefaultEntryAssignNew) {
              QueueOutgoing(MessageEq(Message::EntryAssign(
                                "foo", GetParam() ? 0 : 0xffff, 1, value, 0)),
                            IsNull(), IsNull()));
-  EXPECT_CALL(notifier, NotifyEntry(0, StringRef("foo"), value,
+  EXPECT_CALL(notifier, NotifyEntry(0, std::string_view("foo"), value,
                                    NT_NOTIFY_NEW | NT_NOTIFY_LOCAL, UINT_MAX));

  auto ret_val = storage.SetDefaultEntryValue("foo", value);
@@ -423,7 +424,7 @@ TEST_P(StorageTestPopulated, SetEntryFlagsDifferentValue) {
                                          IsNull(), IsNull()));
  }
  EXPECT_CALL(notifier,
-              NotifyEntry(1, StringRef("foo2"), _,
+              NotifyEntry(1, std::string_view("foo2"), _,
                          NT_NOTIFY_FLAGS | NT_NOTIFY_LOCAL, UINT_MAX));
  storage.SetEntryFlags("foo2", 1u);
  EXPECT_EQ(1u, GetEntry("foo2")->flags);
@@ -460,9 +461,10 @@ TEST_P(StorageTestPopulated, DeleteEntryExist) {
    EXPECT_CALL(dispatcher, QueueOutgoing(MessageEq(Message::EntryDelete(1)),
                                          IsNull(), IsNull()));
  }
-  EXPECT_CALL(notifier,
-              NotifyEntry(1, StringRef("foo2"), ValueEq(Value::MakeDouble(0)),
-                          NT_NOTIFY_DELETE | NT_NOTIFY_LOCAL, UINT_MAX));
+  EXPECT_CALL(
+      notifier,
+      NotifyEntry(1, std::string_view("foo2"), ValueEq(Value::MakeDouble(0)),
+                  NT_NOTIFY_DELETE | NT_NOTIFY_LOCAL, UINT_MAX));

  storage.DeleteEntry("foo2");
  ASSERT_EQ(1u, entries().count("foo2"));
@@ -562,58 +564,58 @@ TEST_P(StorageTestPersistent, SavePersistent) {
  wpi::SmallString<256> buf;
  wpi::raw_svector_ostream oss(buf);
  storage.SavePersistent(oss, false);
-  wpi::StringRef out = oss.str();
+  std::string_view out = oss.str();
  // std::fputs(out.c_str(), stderr);
-  wpi::StringRef line, rem = out;
-  std::tie(line, rem) = rem.split('\n');
+  std::string_view line, rem = out;
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("[NetworkTables Storage 3.0]", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("boolean \"\\x00\\x03\\x05\\n\"=true", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("boolean \"\\x3D\"=true", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("boolean \"boolean/false\"=false", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("boolean \"boolean/true\"=true", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("array boolean \"booleanarr/empty\"=", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("array boolean \"booleanarr/one\"=true", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("array boolean \"booleanarr/two\"=true,false", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("double \"double/big\"=1.3e+08", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("double \"double/neg\"=-1.5", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("double \"double/zero\"=0", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("array double \"doublearr/empty\"=", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("array double \"doublearr/one\"=0.5", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("array double \"doublearr/two\"=0.5,-0.25", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("raw \"raw/empty\"=", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("raw \"raw/normal\"=aGVsbG8=", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("raw \"raw/special\"=AAMFCg==", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("string \"string/empty\"=\"\"", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("string \"string/normal\"=\"hello\"", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("string \"string/quoted\"=\"\\\"a\\\"\"", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("string \"string/special\"=\"\\x00\\x03\\x05\\n\"", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("array string \"stringarr/empty\"=", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("array string \"stringarr/one\"=\"hello\"", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("array string \"stringarr/two\"=\"hello\",\"world\\n\"", line);
-  std::tie(line, rem) = rem.split('\n');
+  std::tie(line, rem) = wpi::split(rem, '\n');
  ASSERT_EQ("", line);
 }

@@ -624,13 +626,13 @@ TEST_P(StorageTestEmpty, LoadPersistentBadHeader) {
  wpi::raw_mem_istream iss("");
  EXPECT_CALL(
      warn,
-      Warn(1, wpi::StringRef("header line mismatch, ignoring rest of file")));
+      Warn(1, std::string_view("header line mismatch, ignoring rest of file")));
  EXPECT_FALSE(storage.LoadEntries(iss, "", true, warn_func));

  wpi::raw_mem_istream iss2("[NetworkTables");
  EXPECT_CALL(
      warn,
-      Warn(1, wpi::StringRef("header line mismatch, ignoring rest of file")));
+      Warn(1, std::string_view("header line mismatch, ignoring rest of file")));

  EXPECT_FALSE(storage.LoadEntries(iss2, "", true, warn_func));
  EXPECT_TRUE(entries().empty());
@@ -669,7 +671,7 @@ TEST_P(StorageTestEmpty, LoadPersistentAssign) {
                                            "foo", GetParam() ? 0 : 0xffff, 1,
                                            value, NT_PERSISTENT)),
                                        IsNull(), IsNull()));
-  EXPECT_CALL(notifier, NotifyEntry(0, StringRef("foo"),
+  EXPECT_CALL(notifier, NotifyEntry(0, std::string_view("foo"),
                                    ValueEq(Value::MakeBoolean(true)),
                                    NT_NOTIFY_NEW | NT_NOTIFY_LOCAL, UINT_MAX));

@@ -692,9 +694,10 @@ TEST_P(StorageTestPopulated, LoadPersistentUpdateFlags) {
                QueueOutgoing(MessageEq(Message::FlagsUpdate(1, NT_PERSISTENT)),
                              IsNull(), IsNull()));
  }
-  EXPECT_CALL(notifier,
-              NotifyEntry(1, StringRef("foo2"), ValueEq(Value::MakeDouble(0)),
-                          NT_NOTIFY_FLAGS | NT_NOTIFY_LOCAL, UINT_MAX));
+  EXPECT_CALL(
+      notifier,
+      NotifyEntry(1, std::string_view("foo2"), ValueEq(Value::MakeDouble(0)),
+                  NT_NOTIFY_FLAGS | NT_NOTIFY_LOCAL, UINT_MAX));

  wpi::raw_mem_istream iss(
      "[NetworkTables Storage 3.0]\ndouble \"foo2\"=0.0\n");
@@ -719,9 +722,10 @@ TEST_P(StorageTestPopulated, LoadPersistentUpdateValue) {
                QueueOutgoing(MessageEq(Message::EntryUpdate(1, 2, value)),
                              IsNull(), IsNull()));
  }
-  EXPECT_CALL(notifier,
-              NotifyEntry(1, StringRef("foo2"), ValueEq(Value::MakeDouble(1)),
-                          NT_NOTIFY_UPDATE | NT_NOTIFY_LOCAL, UINT_MAX));
+  EXPECT_CALL(
+      notifier,
+      NotifyEntry(1, std::string_view("foo2"), ValueEq(Value::MakeDouble(1)),
+                  NT_NOTIFY_UPDATE | NT_NOTIFY_LOCAL, UINT_MAX));

  wpi::raw_mem_istream iss(
      "[NetworkTables Storage 3.0]\ndouble \"foo2\"=1.0\n");
@@ -752,10 +756,11 @@ TEST_P(StorageTestPopulated, LoadPersistentUpdateValueFlags) {
                QueueOutgoing(MessageEq(Message::FlagsUpdate(1, NT_PERSISTENT)),
                              IsNull(), IsNull()));
  }
-  EXPECT_CALL(notifier,
-              NotifyEntry(1, StringRef("foo2"), ValueEq(Value::MakeDouble(1)),
-                          NT_NOTIFY_FLAGS | NT_NOTIFY_UPDATE | NT_NOTIFY_LOCAL,
-                          UINT_MAX));
+  EXPECT_CALL(
+      notifier,
+      NotifyEntry(1, std::string_view("foo2"), ValueEq(Value::MakeDouble(1)),
+                  NT_NOTIFY_FLAGS | NT_NOTIFY_UPDATE | NT_NOTIFY_LOCAL,
+                  UINT_MAX));

  wpi::raw_mem_istream iss(
      "[NetworkTables Storage 3.0]\ndouble \"foo2\"=1.0\n");
@@ -817,13 +822,13 @@ TEST_P(StorageTestEmpty, LoadPersistent) {
  EXPECT_EQ(*Value::MakeString(""), *storage.GetEntryValue("string/empty"));
  EXPECT_EQ(*Value::MakeString("hello"),
            *storage.GetEntryValue("string/normal"));
-  EXPECT_EQ(*Value::MakeString(StringRef("\0\3\5\n", 4)),
+  EXPECT_EQ(*Value::MakeString(std::string_view("\0\3\5\n", 4)),
            *storage.GetEntryValue("string/special"));
  EXPECT_EQ(*Value::MakeString("\"a\""),
            *storage.GetEntryValue("string/quoted"));
  EXPECT_EQ(*Value::MakeRaw(""), *storage.GetEntryValue("raw/empty"));
  EXPECT_EQ(*Value::MakeRaw("hello"), *storage.GetEntryValue("raw/normal"));
-  EXPECT_EQ(*Value::MakeRaw(StringRef("\0\3\5\n", 4)),
+  EXPECT_EQ(*Value::MakeRaw(std::string_view("\0\3\5\n", 4)),
            *storage.GetEntryValue("raw/special"));
  EXPECT_EQ(*Value::MakeBooleanArray(std::vector<int>{}),
            *storage.GetEntryValue("booleanarr/empty"));
@@ -845,7 +850,7 @@ TEST_P(StorageTestEmpty, LoadPersistent) {
      *Value::MakeStringArray(std::vector<std::string>{"hello", "world\n"}),
      *storage.GetEntryValue("stringarr/two"));
  EXPECT_EQ(*Value::MakeBoolean(true),
-            *storage.GetEntryValue(StringRef("\0\3\5\n", 4)));
+            *storage.GetEntryValue(std::string_view("\0\3\5\n", 4)));
  EXPECT_EQ(*Value::MakeBoolean(true), *storage.GetEntryValue("="));
 }

@@ -856,7 +861,7 @@ TEST_P(StorageTestEmpty, LoadPersistentWarn) {
  wpi::raw_mem_istream iss(
      "[NetworkTables Storage 3.0]\nboolean \"foo\"=foo\n");
  EXPECT_CALL(
-      warn, Warn(2, wpi::StringRef(
+      warn, Warn(2, std::string_view(
                        "unrecognized boolean value, not 'true' or 'false'")));
  EXPECT_TRUE(storage.LoadEntries(iss, "", true, warn_func));

@@ -874,7 +879,7 @@ TEST_P(StorageTestEmpty, ProcessIncomingEntryAssign) {
        QueueOutgoing(MessageEq(Message::EntryAssign("foo", 0, 0, value, 0)),
                      IsNull(), IsNull()));
  }
-  EXPECT_CALL(notifier, NotifyEntry(0, StringRef("foo"), ValueEq(value),
+  EXPECT_CALL(notifier, NotifyEntry(0, std::string_view("foo"), ValueEq(value),
                                    NT_NOTIFY_NEW, UINT_MAX));

  storage.ProcessIncoming(
@@ -893,7 +898,7 @@ TEST_P(StorageTestPopulateOne, ProcessIncomingEntryAssign) {
        QueueOutgoing(MessageEq(Message::EntryAssign("foo", 0, 1, value, 0)),
                      IsNull(), conn.get()));
  }
-  EXPECT_CALL(notifier, NotifyEntry(0, StringRef("foo"), ValueEq(value),
+  EXPECT_CALL(notifier, NotifyEntry(0, std::string_view("foo"), ValueEq(value),
                                    NT_NOTIFY_UPDATE, UINT_MAX));

  storage.ProcessIncoming(Message::EntryAssign("foo", 0, 1, value, 0),
@@ -918,15 +923,16 @@ TEST_P(StorageTestPopulateOne, ProcessIncomingEntryAssignWithFlags) {
        QueueOutgoing(MessageEq(Message::EntryAssign("foo", 0, 1, value, 0x2)),
                      IsNull(), conn.get()));
    EXPECT_CALL(notifier,
-                NotifyEntry(0, StringRef("foo"), ValueEq(value),
+                NotifyEntry(0, std::string_view("foo"), ValueEq(value),
                            NT_NOTIFY_UPDATE | NT_NOTIFY_FLAGS, UINT_MAX));
  } else {
    // client forces flags back when an assign message is received for an
    // existing entry with different flags
    EXPECT_CALL(dispatcher, QueueOutgoing(MessageEq(Message::FlagsUpdate(0, 0)),
                                          IsNull(), IsNull()));
-    EXPECT_CALL(notifier, NotifyEntry(0, StringRef("foo"), ValueEq(value),
-                                      NT_NOTIFY_UPDATE, UINT_MAX));
+    EXPECT_CALL(notifier,
+                NotifyEntry(0, std::string_view("foo"), ValueEq(value),
+                            NT_NOTIFY_UPDATE, UINT_MAX));
  }

  storage.ProcessIncoming(Message::EntryAssign("foo", 0, 1, value, 0x2),
--- a/ntcore/src/test/native/cpp/StorageTest.h
+++ b/ntcore/src/test/native/cpp/StorageTest.h
@@ -24,7 +24,7 @@ class StorageTest {
  Storage::EntriesMap& entries() { return storage.m_entries; }
  Storage::IdMap& idmap() { return storage.m_idmap; }

-  Storage::Entry* GetEntry(wpi::StringRef name) {
+  Storage::Entry* GetEntry(std::string_view name) {
    auto i = storage.m_entries.find(name);
    return i == storage.m_entries.end() ? &tmp_entry : i->getValue();
  }
--- a/ntcore/src/test/native/cpp/TestPrinters.cpp
+++ b/ntcore/src/test/native/cpp/TestPrinters.cpp
@@ -126,7 +126,7 @@ void PrintTo(const Value& value, std::ostream* os) {
      *os << value.GetDouble();
      break;
    case NT_STRING:
-      *os << '"' << value.GetString().str() << '"';
+      *os << '"' << value.GetString() << '"';
      break;
    case NT_RAW:
      *os << ::testing::PrintToString(value.GetRaw());
--- a/ntcore/src/test/native/cpp/TestPrinters.h
+++ b/ntcore/src/test/native/cpp/TestPrinters.h
@@ -7,15 +7,15 @@

 #include <memory>
 #include <ostream>
-
-#include <wpi/StringRef.h>
+#include <string>
+#include <string_view>

 #include "gtest/gtest.h"

 namespace wpi {

-inline void PrintTo(StringRef str, ::std::ostream* os) {
-  ::testing::internal::PrintStringTo(str.str(), os);
+inline void PrintTo(std::string_view str, ::std::ostream* os) {
+  ::testing::internal::PrintStringTo(std::string{str}, os);
 }

 }  // namespace wpi
--- a/ntcore/src/test/native/cpp/ValueTest.cpp
+++ b/ntcore/src/test/native/cpp/ValueTest.cpp
@@ -2,11 +2,15 @@
 // Open Source Software; you can modify and/or share it under the terms of
 // the WPILib BSD license file in the root directory of this project.

+#include <string_view>
+
 #include "TestPrinters.h"
 #include "Value_internal.h"
 #include "gtest/gtest.h"
 #include "networktables/NetworkTableValue.h"

+using namespace std::string_view_literals;
+
 namespace nt {

 class ValueTest : public ::testing::Test {};
@@ -66,7 +70,7 @@ TEST_F(ValueTest, String) {
  NT_InitValue(&cv);
  ConvertToC(*v, &cv);
  ASSERT_EQ(NT_STRING, cv.type);
-  ASSERT_EQ(wpi::StringRef("hello"), cv.data.v_string.str);
+  ASSERT_EQ("hello"sv, cv.data.v_string.str);
  ASSERT_EQ(5u, cv.data.v_string.len);

  v = Value::MakeString("goodbye");
@@ -74,7 +78,7 @@ TEST_F(ValueTest, String) {
  ASSERT_EQ("goodbye", v->GetString());
  ConvertToC(*v, &cv);
  ASSERT_EQ(NT_STRING, cv.type);
-  ASSERT_EQ(wpi::StringRef("goodbye"), cv.data.v_string.str);
+  ASSERT_EQ("goodbye"sv, cv.data.v_string.str);
  ASSERT_EQ(7u, cv.data.v_string.len);

  NT_DisposeValue(&cv);
@@ -88,7 +92,7 @@ TEST_F(ValueTest, Raw) {
  NT_InitValue(&cv);
  ConvertToC(*v, &cv);
  ASSERT_EQ(NT_RAW, cv.type);
-  ASSERT_EQ(wpi::StringRef("hello"), cv.data.v_string.str);
+  ASSERT_EQ("hello"sv, cv.data.v_string.str);
  ASSERT_EQ(5u, cv.data.v_string.len);

  v = Value::MakeRaw("goodbye");
@@ -96,7 +100,7 @@ TEST_F(ValueTest, Raw) {
  ASSERT_EQ("goodbye", v->GetRaw());
  ConvertToC(*v, &cv);
  ASSERT_EQ(NT_RAW, cv.type);
-  ASSERT_EQ(wpi::StringRef("goodbye"), cv.data.v_string.str);
+  ASSERT_EQ("goodbye"sv, cv.data.v_string.str);
  ASSERT_EQ(7u, cv.data.v_string.len);

  NT_DisposeValue(&cv);
@@ -190,17 +194,17 @@ TEST_F(ValueTest, StringArray) {
  auto v = Value::MakeStringArray(std::move(vec));
  ASSERT_EQ(NT_STRING_ARRAY, v->type());
  ASSERT_EQ(3u, v->GetStringArray().size());
-  ASSERT_EQ(wpi::StringRef("hello"), v->GetStringArray()[0]);
-  ASSERT_EQ(wpi::StringRef("goodbye"), v->GetStringArray()[1]);
-  ASSERT_EQ(wpi::StringRef("string"), v->GetStringArray()[2]);
+  ASSERT_EQ("hello"sv, v->GetStringArray()[0]);
+  ASSERT_EQ("goodbye"sv, v->GetStringArray()[1]);
+  ASSERT_EQ("string"sv, v->GetStringArray()[2]);
  NT_Value cv;
  NT_InitValue(&cv);
  ConvertToC(*v, &cv);
  ASSERT_EQ(NT_STRING_ARRAY, cv.type);
  ASSERT_EQ(3u, cv.data.arr_string.size);
-  ASSERT_EQ(wpi::StringRef("hello"), cv.data.arr_string.arr[0].str);
-  ASSERT_EQ(wpi::StringRef("goodbye"), cv.data.arr_string.arr[1].str);
-  ASSERT_EQ(wpi::StringRef("string"), cv.data.arr_string.arr[2].str);
+  ASSERT_EQ("hello"sv, cv.data.arr_string.arr[0].str);
+  ASSERT_EQ("goodbye"sv, cv.data.arr_string.arr[1].str);
+  ASSERT_EQ("string"sv, cv.data.arr_string.arr[2].str);

  // assign with same size
  vec.clear();
@@ -210,15 +214,15 @@ TEST_F(ValueTest, StringArray) {
  v = Value::MakeStringArray(vec);
  ASSERT_EQ(NT_STRING_ARRAY, v->type());
  ASSERT_EQ(3u, v->GetStringArray().size());
-  ASSERT_EQ(wpi::StringRef("s1"), v->GetStringArray()[0]);
-  ASSERT_EQ(wpi::StringRef("str2"), v->GetStringArray()[1]);
-  ASSERT_EQ(wpi::StringRef("string3"), v->GetStringArray()[2]);
+  ASSERT_EQ("s1"sv, v->GetStringArray()[0]);
+  ASSERT_EQ("str2"sv, v->GetStringArray()[1]);
+  ASSERT_EQ("string3"sv, v->GetStringArray()[2]);
  ConvertToC(*v, &cv);
  ASSERT_EQ(NT_STRING_ARRAY, cv.type);
  ASSERT_EQ(3u, cv.data.arr_string.size);
-  ASSERT_EQ(wpi::StringRef("s1"), cv.data.arr_string.arr[0].str);
-  ASSERT_EQ(wpi::StringRef("str2"), cv.data.arr_string.arr[1].str);
-  ASSERT_EQ(wpi::StringRef("string3"), cv.data.arr_string.arr[2].str);
+  ASSERT_EQ("s1"sv, cv.data.arr_string.arr[0].str);
+  ASSERT_EQ("str2"sv, cv.data.arr_string.arr[1].str);
+  ASSERT_EQ("string3"sv, cv.data.arr_string.arr[2].str);

  // assign with different size
  vec.clear();
@@ -227,13 +231,13 @@ TEST_F(ValueTest, StringArray) {
  v = Value::MakeStringArray(std::move(vec));
  ASSERT_EQ(NT_STRING_ARRAY, v->type());
  ASSERT_EQ(2u, v->GetStringArray().size());
-  ASSERT_EQ(wpi::StringRef("short"), v->GetStringArray()[0]);
-  ASSERT_EQ(wpi::StringRef("er"), v->GetStringArray()[1]);
+  ASSERT_EQ("short"sv, v->GetStringArray()[0]);
+  ASSERT_EQ("er"sv, v->GetStringArray()[1]);
  ConvertToC(*v, &cv);
  ASSERT_EQ(NT_STRING_ARRAY, cv.type);
  ASSERT_EQ(2u, cv.data.arr_string.size);
-  ASSERT_EQ(wpi::StringRef("short"), cv.data.arr_string.arr[0].str);
-  ASSERT_EQ(wpi::StringRef("er"), cv.data.arr_string.arr[1].str);
+  ASSERT_EQ("short"sv, cv.data.arr_string.arr[0].str);
+  ASSERT_EQ("er"sv, cv.data.arr_string.arr[1].str);

  NT_DisposeValue(&cv);
 }
--- a/ntcore/src/test/native/cpp/WireDecoderTest.cpp
+++ b/ntcore/src/test/native/cpp/WireDecoderTest.cpp
@@ -7,13 +7,14 @@
 #include <cfloat>
 #include <climits>
 #include <string>
-
-#include <wpi/StringRef.h>
+#include <string_view>

 #include "TestPrinters.h"
 #include "WireDecoder.h"
 #include "gtest/gtest.h"

+using namespace std::string_view_literals;
+
 namespace nt {

 class WireDecoderTest : public ::testing::Test {
@@ -21,8 +22,8 @@ class WireDecoderTest : public ::testing::Test {
  WireDecoderTest() {
    v_boolean = Value::MakeBoolean(true);
    v_double = Value::MakeDouble(1.0);
-    v_string = Value::MakeString(wpi::StringRef("hello"));
-    v_raw = Value::MakeRaw(wpi::StringRef("hello"));
+    v_string = Value::MakeString("hello"sv);
+    v_raw = Value::MakeRaw("hello"sv);
    v_boolean_array = Value::MakeBooleanArray(std::vector<int>{0, 1, 0});
    v_boolean_array_big = Value::MakeBooleanArray(std::vector<int>(255));
    v_double_array = Value::MakeDoubleArray(std::vector<double>{0.5, 0.25});
@@ -268,7 +269,7 @@ TEST_F(WireDecoderTest, ReadStringValue2) {
  ASSERT_TRUE(static_cast<bool>(val));
  EXPECT_EQ(*v_string, *val);

-  auto v_bye = Value::MakeString(wpi::StringRef("bye"));
+  auto v_bye = Value::MakeString("bye"sv);
  val = d.ReadValue(NT_STRING);
  ASSERT_TRUE(static_cast<bool>(val));
  EXPECT_EQ(*v_bye, *val);
@@ -443,7 +444,7 @@ TEST_F(WireDecoderTest, ReadStringValue3) {
  ASSERT_TRUE(static_cast<bool>(val));
  EXPECT_EQ(*v_string, *val);

-  auto v_bye = Value::MakeString(wpi::StringRef("bye"));
+  auto v_bye = Value::MakeString("bye"sv);
  val = d.ReadValue(NT_STRING);
  ASSERT_TRUE(static_cast<bool>(val));
  EXPECT_EQ(*v_bye, *val);
@@ -467,7 +468,7 @@ TEST_F(WireDecoderTest, ReadRawValue3) {
  ASSERT_TRUE(static_cast<bool>(val));
  EXPECT_EQ(*v_raw, *val);

-  auto v_bye = Value::MakeRaw(wpi::StringRef("bye"));
+  auto v_bye = Value::MakeRaw("bye"sv);
  val = d.ReadValue(NT_RAW);
  ASSERT_TRUE(static_cast<bool>(val));
  EXPECT_EQ(*v_bye, *val);
--- a/ntcore/src/test/native/cpp/WireEncoderTest.cpp
+++ b/ntcore/src/test/native/cpp/WireEncoderTest.cpp
@@ -5,8 +5,7 @@
 #include <cfloat>
 #include <climits>
 #include <string>
-
-#include <wpi/StringRef.h>
+#include <string_view>

 #include "TestPrinters.h"
 #include "WireEncoder.h"
@@ -14,6 +13,8 @@

 #define BUFSIZE 1024

+using namespace std::string_view_literals;
+
 namespace nt {

 class WireEncoderTest : public ::testing::Test {
@@ -22,8 +23,8 @@ class WireEncoderTest : public ::testing::Test {
    v_empty = std::make_shared<Value>();
    v_boolean = Value::MakeBoolean(true);
    v_double = Value::MakeDouble(1.0);
-    v_string = Value::MakeString(wpi::StringRef("hello"));
-    v_raw = Value::MakeRaw(wpi::StringRef("hello"));
+    v_string = Value::MakeString("hello"sv);
+    v_raw = Value::MakeRaw("hello"sv);
    v_boolean_array = Value::MakeBooleanArray(std::vector<int>{0, 1, 0});
    v_boolean_array_big = Value::MakeBooleanArray(std::vector<int>(256));
    v_double_array = Value::MakeDoubleArray(std::vector<double>{0.5, 0.25});
@@ -83,8 +84,7 @@ TEST_F(WireEncoderTest, Write8) {
  e.Write8(0x101u);  // should be truncated
  e.Write8(0u);
  ASSERT_EQ(3u, e.size() - off);
-  ASSERT_EQ(wpi::StringRef("\x05\x01\x00", 3),
-            wpi::StringRef(e.data(), e.size()).substr(off));
+  ASSERT_EQ("\x05\x01\x00"sv, std::string_view(e.data(), e.size()).substr(off));
 }

 TEST_F(WireEncoderTest, Write16) {
@@ -98,8 +98,8 @@ TEST_F(WireEncoderTest, Write16) {
  e.Write16(0x4567u);
  e.Write16(0u);
  ASSERT_EQ(8u, e.size() - off);
-  ASSERT_EQ(wpi::StringRef("\x00\x05\x00\x01\x45\x67\x00\x00", 8),
-            wpi::StringRef(e.data(), e.size()).substr(off));
+  ASSERT_EQ("\x00\x05\x00\x01\x45\x67\x00\x00"sv,
+            std::string_view(e.data(), e.size()).substr(off));
 }

 TEST_F(WireEncoderTest, Write32) {
@@ -114,10 +114,10 @@ TEST_F(WireEncoderTest, Write32) {
  e.Write32(0x12345678ul);
  e.Write32(0ul);
  ASSERT_EQ(20u, e.size() - off);
-  ASSERT_EQ(wpi::StringRef("\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\xab\xcd"
-                           "\x12\x34\x56\x78\x00\x00\x00\x00",
-                           20),
-            wpi::StringRef(e.data(), e.size()).substr(off));
+  ASSERT_EQ(std::string_view("\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\xab\xcd"
+                             "\x12\x34\x56\x78\x00\x00\x00\x00",
+                             20),
+            std::string_view(e.data(), e.size()).substr(off));
 }

 TEST_F(WireEncoderTest, WriteDouble) {
@@ -134,13 +134,13 @@ TEST_F(WireEncoderTest, WriteDouble) {
  ASSERT_EQ(40u, e.size() - off);
  // golden values except min and max from
  // http://www.binaryconvert.com/result_double.html
-  ASSERT_EQ(wpi::StringRef("\x00\x00\x00\x00\x00\x00\x00\x00"
-                           "\x41\x0c\x13\x80\x00\x00\x00\x00"
-                           "\x7f\xf0\x00\x00\x00\x00\x00\x00"
-                           "\x00\x10\x00\x00\x00\x00\x00\x00"
-                           "\x7f\xef\xff\xff\xff\xff\xff\xff",
-                           40),
-            wpi::StringRef(e.data(), e.size()).substr(off));
+  ASSERT_EQ(std::string_view("\x00\x00\x00\x00\x00\x00\x00\x00"
+                             "\x41\x0c\x13\x80\x00\x00\x00\x00"
+                             "\x7f\xf0\x00\x00\x00\x00\x00\x00"
+                             "\x00\x10\x00\x00\x00\x00\x00\x00"
+                             "\x7f\xef\xff\xff\xff\xff\xff\xff",
+                             40),
+            std::string_view(e.data(), e.size()).substr(off));
 }

 TEST_F(WireEncoderTest, WriteUleb128) {
@@ -153,8 +153,8 @@ TEST_F(WireEncoderTest, WriteUleb128) {
  e.WriteUleb128(0x7ful);
  e.WriteUleb128(0x80ul);
  ASSERT_EQ(4u, e.size() - off);
-  ASSERT_EQ(wpi::StringRef("\x00\x7f\x80\x01", 4),
-            wpi::StringRef(e.data(), e.size()).substr(off));
+  ASSERT_EQ("\x00\x7f\x80\x01"sv,
+            std::string_view(e.data(), e.size()).substr(off));
 }

 TEST_F(WireEncoderTest, WriteType) {
@@ -173,8 +173,8 @@ TEST_F(WireEncoderTest, WriteType) {
  e.WriteType(NT_RPC);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(8u, e.size() - off);
-  ASSERT_EQ(wpi::StringRef("\x00\x01\x02\x03\x10\x11\x12\x20", 8),
-            wpi::StringRef(e.data(), e.size()).substr(off));
+  ASSERT_EQ("\x00\x01\x02\x03\x10\x11\x12\x20"sv,
+            std::string_view(e.data(), e.size()).substr(off));
 }

 TEST_F(WireEncoderTest, WriteTypeError) {
@@ -235,7 +235,7 @@ TEST_F(WireEncoderTest, WriteBooleanValue2) {
  e.WriteValue(*v_false);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(2u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x01\x00", 2), wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ("\x01\x00"sv, std::string_view(e.data(), e.size()));
 }

 TEST_F(WireEncoderTest, WriteDoubleValue2) {
@@ -243,8 +243,8 @@ TEST_F(WireEncoderTest, WriteDoubleValue2) {
  e.WriteValue(*v_double);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(8u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8),
-            wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ("\x3f\xf0\x00\x00\x00\x00\x00\x00"sv,
+            std::string_view(e.data(), e.size()));
 }

 TEST_F(WireEncoderTest, WriteStringValue2) {
@@ -252,8 +252,7 @@ TEST_F(WireEncoderTest, WriteStringValue2) {
  e.WriteValue(*v_string);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(7u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x00\x05hello", 7),
-            wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ("\x00\x05hello"sv, std::string_view(e.data(), e.size()));
 }

 TEST_F(WireEncoderTest, WriteBooleanArrayValue2) {
@@ -261,15 +260,14 @@ TEST_F(WireEncoderTest, WriteBooleanArrayValue2) {
  e.WriteValue(*v_boolean_array);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 3u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x03\x00\x01\x00", 4),
-            wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ("\x03\x00\x01\x00"sv, std::string_view(e.data(), e.size()));

  // truncated
  e.Reset();
  e.WriteValue(*v_boolean_array_big);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 255u, e.size());
-  ASSERT_EQ(wpi::StringRef("\xff\x00", 2), wpi::StringRef(e.data(), 2));
+  ASSERT_EQ("\xff\x00"sv, std::string_view(e.data(), 2));
 }

 TEST_F(WireEncoderTest, WriteDoubleArrayValue2) {
@@ -277,17 +275,17 @@ TEST_F(WireEncoderTest, WriteDoubleArrayValue2) {
  e.WriteValue(*v_double_array);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 2u * 8u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x02\x3f\xe0\x00\x00\x00\x00\x00\x00"
-                           "\x3f\xd0\x00\x00\x00\x00\x00\x00",
-                           17),
-            wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ(std::string_view("\x02\x3f\xe0\x00\x00\x00\x00\x00\x00"
+                             "\x3f\xd0\x00\x00\x00\x00\x00\x00",
+                             17),
+            std::string_view(e.data(), e.size()));

  // truncated
  e.Reset();
  e.WriteValue(*v_double_array_big);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 255u * 8u, e.size());
-  ASSERT_EQ(wpi::StringRef("\xff\x00", 2), wpi::StringRef(e.data(), 2));
+  ASSERT_EQ("\xff\x00"sv, std::string_view(e.data(), 2));
 }

 TEST_F(WireEncoderTest, WriteStringArrayValue2) {
@@ -295,15 +293,15 @@ TEST_F(WireEncoderTest, WriteStringArrayValue2) {
  e.WriteValue(*v_string_array);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 7u + 9u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x02\x00\x05hello\x00\x07goodbye", 17),
-            wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ("\x02\x00\x05hello\x00\x07goodbye"sv,
+            std::string_view(e.data(), e.size()));

  // truncated
  e.Reset();
  e.WriteValue(*v_string_array_big);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 255u * 3u, e.size());
-  ASSERT_EQ(wpi::StringRef("\xff\x00\x01", 3), wpi::StringRef(e.data(), 3));
+  ASSERT_EQ("\xff\x00\x01"sv, std::string_view(e.data(), 3));
 }

 TEST_F(WireEncoderTest, WriteValueError2) {
@@ -346,7 +344,7 @@ TEST_F(WireEncoderTest, WriteBooleanValue3) {
  e.WriteValue(*v_false);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(2u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x01\x00", 2), wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ("\x01\x00"sv, std::string_view(e.data(), e.size()));
 }

 TEST_F(WireEncoderTest, WriteDoubleValue3) {
@@ -354,8 +352,8 @@ TEST_F(WireEncoderTest, WriteDoubleValue3) {
  e.WriteValue(*v_double);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(8u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x3f\xf0\x00\x00\x00\x00\x00\x00", 8),
-            wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ("\x3f\xf0\x00\x00\x00\x00\x00\x00"sv,
+            std::string_view(e.data(), e.size()));
 }

 TEST_F(WireEncoderTest, WriteStringValue3) {
@@ -363,7 +361,7 @@ TEST_F(WireEncoderTest, WriteStringValue3) {
  e.WriteValue(*v_string);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(6u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x05hello", 6), wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ("\x05hello"sv, std::string_view(e.data(), e.size()));
 }

 TEST_F(WireEncoderTest, WriteRawValue3) {
@@ -371,7 +369,7 @@ TEST_F(WireEncoderTest, WriteRawValue3) {
  e.WriteValue(*v_raw);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(6u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x05hello", 6), wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ("\x05hello"sv, std::string_view(e.data(), e.size()));
 }

 TEST_F(WireEncoderTest, WriteBooleanArrayValue3) {
@@ -379,15 +377,14 @@ TEST_F(WireEncoderTest, WriteBooleanArrayValue3) {
  e.WriteValue(*v_boolean_array);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 3u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x03\x00\x01\x00", 4),
-            wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ("\x03\x00\x01\x00"sv, std::string_view(e.data(), e.size()));

  // truncated
  e.Reset();
  e.WriteValue(*v_boolean_array_big);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 255u, e.size());
-  ASSERT_EQ(wpi::StringRef("\xff\x00", 2), wpi::StringRef(e.data(), 2));
+  ASSERT_EQ("\xff\x00"sv, std::string_view(e.data(), 2));
 }

 TEST_F(WireEncoderTest, WriteDoubleArrayValue3) {
@@ -395,17 +392,17 @@ TEST_F(WireEncoderTest, WriteDoubleArrayValue3) {
  e.WriteValue(*v_double_array);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 2u * 8u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x02\x3f\xe0\x00\x00\x00\x00\x00\x00"
-                           "\x3f\xd0\x00\x00\x00\x00\x00\x00",
-                           17),
-            wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ(std::string_view("\x02\x3f\xe0\x00\x00\x00\x00\x00\x00"
+                             "\x3f\xd0\x00\x00\x00\x00\x00\x00",
+                             17),
+            std::string_view(e.data(), e.size()));

  // truncated
  e.Reset();
  e.WriteValue(*v_double_array_big);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 255u * 8u, e.size());
-  ASSERT_EQ(wpi::StringRef("\xff\x00", 2), wpi::StringRef(e.data(), 2));
+  ASSERT_EQ("\xff\x00"sv, std::string_view(e.data(), 2));
 }

 TEST_F(WireEncoderTest, WriteStringArrayValue3) {
@@ -413,15 +410,14 @@ TEST_F(WireEncoderTest, WriteStringArrayValue3) {
  e.WriteValue(*v_string_array);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 6u + 8u, e.size());
-  ASSERT_EQ(wpi::StringRef("\x02\x05hello\x07goodbye", 15),
-            wpi::StringRef(e.data(), e.size()));
+  ASSERT_EQ("\x02\x05hello\x07goodbye"sv, std::string_view(e.data(), e.size()));

  // truncated
  e.Reset();
  e.WriteValue(*v_string_array_big);
  ASSERT_EQ(nullptr, e.error());
  ASSERT_EQ(1u + 255u * 2u, e.size());
-  ASSERT_EQ(wpi::StringRef("\xff\x01", 2), wpi::StringRef(e.data(), 2));
+  ASSERT_EQ("\xff\x01"sv, std::string_view(e.data(), 2));
 }

 TEST_F(WireEncoderTest, WriteValueError3) {
@@ -445,14 +441,13 @@ TEST_F(WireEncoderTest, WriteString2) {
  e.WriteString(s_normal);
  EXPECT_EQ(nullptr, e.error());
  EXPECT_EQ(7u, e.size());
-  EXPECT_EQ(wpi::StringRef("\x00\x05hello", 7),
-            wpi::StringRef(e.data(), e.size()));
+  EXPECT_EQ("\x00\x05hello"sv, std::string_view(e.data(), e.size()));

  e.Reset();
  e.WriteString(s_long);
  EXPECT_EQ(nullptr, e.error());
  ASSERT_EQ(130u, e.size());
-  EXPECT_EQ(wpi::StringRef("\x00\x80**", 4), wpi::StringRef(e.data(), 4));
+  EXPECT_EQ("\x00\x80**"sv, std::string_view(e.data(), 4));
  EXPECT_EQ('*', e.data()[128]);
  EXPECT_EQ('x', e.data()[129]);

@@ -461,7 +456,7 @@ TEST_F(WireEncoderTest, WriteString2) {
  e.WriteString(s_big);
  EXPECT_EQ(nullptr, e.error());
  ASSERT_EQ(65537u, e.size());
-  EXPECT_EQ(wpi::StringRef("\xff\xff**", 4), wpi::StringRef(e.data(), 4));
+  EXPECT_EQ("\xff\xff**"sv, std::string_view(e.data(), 4));
  EXPECT_EQ('*', e.data()[65535]);
  EXPECT_EQ('x', e.data()[65536]);
 }
@@ -479,13 +474,13 @@ TEST_F(WireEncoderTest, WriteString3) {
  e.WriteString(s_normal);
  EXPECT_EQ(nullptr, e.error());
  EXPECT_EQ(6u, e.size());
-  EXPECT_EQ(wpi::StringRef("\x05hello", 6), wpi::StringRef(e.data(), e.size()));
+  EXPECT_EQ("\x05hello"sv, std::string_view(e.data(), e.size()));

  e.Reset();
  e.WriteString(s_long);
  EXPECT_EQ(nullptr, e.error());
  ASSERT_EQ(130u, e.size());
-  EXPECT_EQ(wpi::StringRef("\x80\x01**", 4), wpi::StringRef(e.data(), 4));
+  EXPECT_EQ("\x80\x01**"sv, std::string_view(e.data(), 4));
  EXPECT_EQ('*', e.data()[128]);
  EXPECT_EQ('x', e.data()[129]);

@@ -494,7 +489,7 @@ TEST_F(WireEncoderTest, WriteString3) {
  e.WriteString(s_big);
  EXPECT_EQ(nullptr, e.error());
  ASSERT_EQ(65540u, e.size());
-  EXPECT_EQ(wpi::StringRef("\x81\x80\x04*", 4), wpi::StringRef(e.data(), 4));
+  EXPECT_EQ("\x81\x80\x04*"sv, std::string_view(e.data(), 4));
  EXPECT_EQ('*', e.data()[65536]);
  EXPECT_EQ('x', e.data()[65537]);
  EXPECT_EQ('x', e.data()[65538]);