commit 2f6affd1fdfe52c747a7e0917ab11ccdfa3866a8
author William A. Kennington III <wak@google.com> Sun Jan 28 17:49:41 2024 -0800
committer William A. Kennington III <wak@google.com> Sun Jan 28 17:50:20 2024 -0800
tree 52ea789f9280a3c5e4d8d62823007311f3dffc68
parent ac18d11eb9c6f6ef292b5dc50b30f83f87d0c2f5

raw: Use a more selective exception

This makes it easier for us to select for incomplete expansions when
parsing errors.

Change-Id: I07863a2ff29567196eb72bcaf070db7c7614add2
Signed-off-by: William A. Kennington III <wak@google.com>

include/stdplus/raw.hpp

diff --git a/include/stdplus/raw.hpp b/include/stdplus/raw.hpp
index 77bcf5d..c9dbf74 100644
--- a/include/stdplus/raw.hpp
+++ b/include/stdplus/raw.hpp
@@ -1,5 +1,6 @@
 #pragma once
 #include <stdplus/concepts.hpp>
+#include <stdplus/exception.hpp>
 
 #include <algorithm>
 #include <format>
@@ -82,7 +83,7 @@
         const size_t bytes = std::size(c) * sizeof(*std::data(c));             \
         if (bytes comp sizeof(ret))                                            \
         {                                                                      \
-            throw std::runtime_error(                                          \
+            throw exception::Incomplete(                                       \
                 std::format(#func ": {} < {}", bytes, sizeof(ret)));           \
         }                                                                      \
         const auto c_bytes = reinterpret_cast<const std::byte*>(std::data(c)); \
@@ -117,7 +118,7 @@
         const size_t bytes = std::size(c) * sizeof(*std::data(c));             \
         if (bytes comp sizeof(Tp))                                             \
         {                                                                      \
-            throw std::runtime_error(                                          \
+            throw exception::Incomplete(                                       \
                 std::format(#func ": {} < {}", bytes, sizeof(Tp)));            \
         }                                                                      \
         return *reinterpret_cast<Tp*>(std::data(c));                           \

test/raw.cpp

diff --git a/test/raw.cpp b/test/raw.cpp
index 770c7b4..bcfa73e 100644
--- a/test/raw.cpp
+++ b/test/raw.cpp
@@ -30,10 +30,10 @@
 TEST(CopyFrom, Empty)
 {
     const std::string_view cs;
-    EXPECT_THROW(copyFrom<int>(cs), std::runtime_error);
+    EXPECT_THROW(copyFrom<int>(cs), exception::Incomplete);
     std::string_view s;
-    EXPECT_THROW(copyFrom<int>(s), std::runtime_error);
-    EXPECT_THROW(copyFromStrict<char>(s), std::runtime_error);
+    EXPECT_THROW(copyFrom<int>(s), exception::Incomplete);
+    EXPECT_THROW(copyFromStrict<char>(s), exception::Incomplete);
 }
 
 TEST(CopyFrom, Basic)
@@ -48,7 +48,7 @@
 {
     const std::vector<char> s = {'a', 'b', 'c'};
     EXPECT_EQ('a', copyFrom<char>(s));
-    EXPECT_THROW(copyFromStrict<char>(s), std::runtime_error);
+    EXPECT_THROW(copyFromStrict<char>(s), exception::Incomplete);
     const char s2[] = "def";
     EXPECT_EQ('d', copyFrom<char>(s2));
 }
@@ -66,10 +66,10 @@
 TEST(RefFrom, Empty)
 {
     const std::string_view cs;
-    EXPECT_THROW(refFrom<Int>(cs), std::runtime_error);
+    EXPECT_THROW(refFrom<Int>(cs), exception::Incomplete);
     std::string_view s;
-    EXPECT_THROW(refFrom<Int>(s), std::runtime_error);
-    EXPECT_THROW(refFromStrict<Int>(s), std::runtime_error);
+    EXPECT_THROW(refFrom<Int>(s), exception::Incomplete);
+    EXPECT_THROW(refFromStrict<Int>(s), exception::Incomplete);
 }
 
 TEST(RefFrom, Basic)
@@ -84,7 +84,7 @@
 {
     const std::vector<char> s = {'a', 'b', 'c'};
     EXPECT_EQ('a', refFrom<char>(s));
-    EXPECT_THROW(refFromStrict<char>(s), std::runtime_error);
+    EXPECT_THROW(refFromStrict<char>(s), exception::Incomplete);
     const char s2[] = "def";
     EXPECT_EQ('d', refFrom<char>(s2));
 }
@@ -94,7 +94,7 @@
     std::string str = "aaaa";
     str.resize(1);
     std::string_view s(str);
-    EXPECT_THROW(extract<int>(s), std::runtime_error);
+    EXPECT_THROW(extract<int>(s), exception::Incomplete);
     EXPECT_EQ("a", s);
 }
 
@@ -119,7 +119,7 @@
     std::array<char, sizeof(Int)> buf{};
     buf[0] = 'a';
     std::string_view s(buf.data(), 1);
-    EXPECT_THROW(extractRef<Int>(s), std::runtime_error);
+    EXPECT_THROW(extractRef<Int>(s), exception::Incomplete);
     EXPECT_EQ("a", s);
 }
 
@@ -173,7 +173,7 @@
 {
     const std::vector<char> v = {'c'};
     std::span<const char> s = v;
-    EXPECT_THROW(extract<int>(s), std::runtime_error);
+    EXPECT_THROW(extract<int>(s), exception::Incomplete);
     EXPECT_THAT(s, ElementsAreArray(v));
 }
 
@@ -197,7 +197,7 @@
 {
     const std::vector<char> v = {'c'};
     std::span<const char> s = v;
-    EXPECT_THROW(extractRef<Int>(s), std::runtime_error);
+    EXPECT_THROW(extractRef<Int>(s), exception::Incomplete);
     EXPECT_THAT(s, ElementsAreArray(v));
 }