Enhancements to span and other functionality, changed byte compares to integer compares for Catch2 stringify weirdness on MSVC and macos

Author: cliffg-softwarelibre

test/shared_buffer_test.cpp

@@ -20,24 +20,35 @@
 #include <list>
 #include <string_view>
 #include <span>
+#include <array>
+#include <algorithm> // std::copy
 #include <bit> // std::bit_cast
 
 #include "buffer/shared_buffer.hpp"
 
 #include "utility/repeat.hpp"
-#include "utility/make_byte_array.hpp"
+#include "utility/byte_array.hpp"
 
-constexpr std::byte Harhar { 42 };
-constexpr int N = 11;
+constexpr std::size_t test_data_size { 12u };
+using test_data_type = std::array<std::byte, test_data_size>;
+constexpr test_data_type test_data { chops::make_byte_array( 40, 41, 42, 43, 44, 60, 59, 58, 57, 56, 42, 42 ) };
+char test_data_char[test_data_size] { 40, 41, 42, 43, 44, 60, 59, 58, 57, 56, 42, 42 };
+const char* test_data_char_ptr {test_data_char};
 
+template <typename SB>
+bool check_sb_against_test_data(SB sb) {
+  REQUIRE (sb.size() == test_data_size);
+  test_data_type buf;
+  std::copy(sb.data(), sb.data()+sb.size(), buf.begin());
+  return chops::compare_byte_arrays(buf, test_data);
+}
 
 template <typename SB, typename PT>
 SB generic_pointer_construction_test() {
-  auto arr = chops::make_byte_array( 40, 41, 42, 43, 44, 60, 59, 58, 57, 56, 42, 42 );
-  auto ptr = std::bit_cast<const PT *>(arr.data());
-  SB sb(ptr, arr.size());
+  auto ptr { std::bit_cast<const PT *>(test_data.data()) };
+  SB sb(ptr, test_data_size);
   REQUIRE_FALSE (sb.empty());
-  chops::repeat(static_cast<int>(arr.size()), [&sb, arr] (int i) { REQUIRE(*(sb.data()+i) == arr[i]); } );
+  REQUIRE (check_sb_against_test_data(sb));
   return sb;
 }
 
@@ -49,48 +60,85 @@ void generic_pointer_append_test() {
   const PT* ptr_arr { arr };
   sb.append (ptr_arr, 3);
   REQUIRE (sb.size() == (sav_sz + 3));
-  std::span<const PT> sp { arr };
+  std::span<const PT, 3> sp { arr };
   sb.append (sp);
   REQUIRE (sb.size() == (sav_sz + 6));
 }
 
 template <typename SB>
-void common_methods_test(const std::byte* buf, typename SB::size_type sz) {
+void check_sb(SB sb) {
+  REQUIRE_FALSE (sb.empty());
+  REQUIRE (sb.size() == test_data_size);
+  REQUIRE (check_sb_against_test_data(sb));
+}
 
-  REQUIRE (sz > 2);
+template <typename SB>
+void common_ctor_test() {
 
-  SB sb(buf, sz);
-  REQUIRE_FALSE (sb.empty());
   {
-    SB sb2(buf, sz);
-    REQUIRE_FALSE (sb2.empty());
-    REQUIRE (sb == sb2);
+    std::span<const std::byte, test_data_size> sp { test_data };
+    SB sb{sp};
+    check_sb(sb);
   }
   {
-    std::list<std::byte> lst (buf, buf+sz);
-    SB sb2(lst.cbegin(), lst.cend());
-    REQUIRE_FALSE (sb2.empty());
-    REQUIRE (sb == sb2);
+    std::span<const std::byte> sp { test_data.data(), test_data.size() };
+    SB sb{sp};
+    check_sb(sb);
   }
   {
-    auto ba = chops::make_byte_array(buf[0], buf[1]);
-    SB sb2(ba.cbegin(), ba.cend());
-    REQUIRE_FALSE (sb2.empty());
-    REQUIRE (((sb2 < sb) != 0)); // uses spaceship operator
-    REQUIRE (sb2 != sb);
+    SB sb{test_data.data(), test_data.size()};
+    check_sb(sb);
   }
   {
-    auto ba = chops::make_byte_array(0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
-    SB sb2(ba.cbegin(), ba.cend());
-    REQUIRE_FALSE (sb2.empty());
-    REQUIRE (sb2 != sb);
+    std::span<const char, test_data_size> sp { test_data_char };
+    SB sb{sp};
+    check_sb(sb);
+  }
+  {
+    std::span<const char> sp { test_data_char, test_data_char+test_data_size };
+    SB sb{sp};
+    check_sb(sb);
+  }
+  {
+    SB sb{test_data_char_ptr, test_data_size};
+    check_sb(sb);
+  }
+
+  {
+    std::list<std::byte> lst {test_data.cbegin(), test_data.cend()};
+    SB sb {lst.cbegin(), lst.cend()};
+    check_sb(sb);
   }
+  {
+    SB sb1{test_data.data(), test_data.size()};
+    SB sb2{test_data.data(), test_data.size()};
+    REQUIRE (sb1 == sb2);
+  }
+  {
+    SB sb1{test_data.data(), test_data.size()};
+    SB sb2{sb1};
+    REQUIRE (sb1 == sb2);
+  }
+
+}
+
+template <typename SB>
+void common_comparison_test() {
+  auto ba1 { chops::make_byte_array(0x00, 0x00, 0x00) };
+  auto ba2 { chops::make_byte_array(0x00, 0x22, 0x33) };
+
+  SB sb1(ba1.cbegin(), ba1.cend());
+  SB sb2(ba2.cbegin(), ba2.cend());
+  REQUIRE_FALSE (sb1.empty());
+  REQUIRE_FALSE (sb2.empty());
+  REQUIRE_FALSE (sb1 == sb2);
+  REQUIRE (((sb1 < sb2) != 0)); // uses spaceship operator
 }
 
 template <typename SB>
 void byte_vector_move_test() {
 
-  auto arr = chops::make_byte_array (0x01, 0x02, 0x03, 0x04, 0x05);
+  auto arr { chops::make_byte_array (0x01, 0x02, 0x03, 0x04, 0x05) };
 
   std::vector<std::byte> bv { arr.cbegin(), arr.cend() };
   SB sb(std::move(bv));
@@ -106,17 +154,24 @@ TEMPLATE_TEST_CASE ( "Generic pointer construction",
 }
 
 
-TEMPLATE_TEST_CASE ( "Shared buffer common methods",
-                     "[const_shared_buffer] [common]",
+TEMPLATE_TEST_CASE ( "Shared buffer common ctor methods",
+                     "[const_shared_buffer] [mutable_shared_buffer] [common]",
+                     chops::mutable_shared_buffer, chops::const_shared_buffer ) {
+  common_ctor_test<TestType>();
+}
+
+TEMPLATE_TEST_CASE ( "Shared buffer common comparison methods",
+                     "[const_shared_buffer] [mutable_shared_buffer] [common]",
                      chops::mutable_shared_buffer, chops::const_shared_buffer ) {
-  auto arr = chops::make_byte_array ( 80, 81, 82, 83, 84, 90, 91, 92 );
-  common_methods_test<TestType>(arr.data(), arr.size());
+  common_comparison_test<TestType>();
 }
 
 TEST_CASE ( "Mutable shared buffer copy construction and assignment",
             "[mutable_shared_buffer] [copy]" ) {
 
-  auto arr = chops::make_byte_array ( 80, 81, 82, 83, 84, 90, 91, 92 );
+  constexpr std::byte Harhar { 42 };
+
+  auto arr { chops::make_byte_array ( 80, 81, 82, 83, 84, 90, 91, 92 ) };
 
   chops::mutable_shared_buffer sb;
   REQUIRE (sb.empty());
@@ -140,18 +195,22 @@ TEST_CASE ( "Mutable shared buffer copy construction and assignment",
 TEST_CASE ( "Mutable shared buffer resize and clear",
             "[mutable_shared_buffer] [resize_and_clear]" ) {
 
+  constexpr int N = 11;
+
   chops::mutable_shared_buffer sb;
+  REQUIRE (sb.empty());
+  REQUIRE (sb.size() == 0);
 
   sb.resize(N);
   REQUIRE (sb.size() == N);
-  chops::repeat(N, [&sb] (int i) { REQUIRE (*(sb.data() + i) == std::byte{0} ); } );
+  chops::repeat(N, [&sb] (int i) { REQUIRE (std::to_integer<int>(*(sb.data() + i)) == 0 ); } );
 
   SECTION ( "Compare two resized mutable shared buffer with same size" ) {
     chops::mutable_shared_buffer sb2(N);
     REQUIRE (sb == sb2);
     chops::repeat(N, [&sb, &sb2] (int i) {
-      REQUIRE (*(sb.data() + i) == std::byte{0} );
-      REQUIRE (*(sb2.data() + i) == std::byte{0} );
+      REQUIRE (std::to_integer<int>(*(sb.data() + i)) == 0 );
+      REQUIRE (std::to_integer<int>(*(sb2.data() + i)) == 0 );
     } );
   }
   SECTION ( "Clear, check size" ) {
@@ -174,15 +233,15 @@ TEST_CASE ( "Mutable shared buffer swap",
   REQUIRE (sb1.size() == arr2.size());
   REQUIRE (sb2.size() == arr1.size());
 
-  REQUIRE (*(sb1.data()+0) == *(arr2.data()+0));
-  REQUIRE (*(sb1.data()+1) == *(arr2.data()+1));
-  REQUIRE (*(sb1.data()+2) == *(arr2.data()+2));
-  REQUIRE (*(sb1.data()+3) == *(arr2.data()+3));
-  REQUIRE (*(sb1.data()+4) == *(arr2.data()+4));
+  REQUIRE (std::to_integer<int>(*(sb1.data()+0)) == std::to_integer<int>(*(arr2.data()+0)));
+  REQUIRE (std::to_integer<int>(*(sb1.data()+1)) == std::to_integer<int>(*(arr2.data()+1)));
+  REQUIRE (std::to_integer<int>(*(sb1.data()+2)) == std::to_integer<int>(*(arr2.data()+2)));
+  REQUIRE (std::to_integer<int>(*(sb1.data()+3)) == std::to_integer<int>(*(arr2.data()+3)));
+  REQUIRE (std::to_integer<int>(*(sb1.data()+4)) == std::to_integer<int>(*(arr2.data()+4)));
 
-  REQUIRE (*(sb2.data()+0) == *(arr1.data()+0));
-  REQUIRE (*(sb2.data()+1) == *(arr1.data()+1));
-  REQUIRE (*(sb2.data()+2) == *(arr1.data()+2));
+  REQUIRE (std::to_integer<int>(*(sb2.data()+0)) == std::to_integer<int>(*(arr1.data()+0)));
+  REQUIRE (std::to_integer<int>(*(sb2.data()+1)) == std::to_integer<int>(*(arr1.data()+1)));
+  REQUIRE (std::to_integer<int>(*(sb2.data()+2)) == std::to_integer<int>(*(arr1.data()+2)));
 }
 
 TEST_CASE ( "Mutable shared buffer append",