Enhancing test with a little bit of span and generic pointer testing

Author: cliffg-softwarelibre

include/buffer/shared_buffer.hpp

@@ -154,9 +154,27 @@ class mutable_shared_buffer {
  * copied into the internal buffer of the @c mutable_shared_buffer. 
  *
  */
-  explicit mutable_shared_buffer(std::span<const std::byte> sp) : 
+  template <std::size_t Ext>
+  explicit mutable_shared_buffer(std::span<const std::byte, Ext> sp) : 
       m_data{std::make_shared<byte_vec>(sp.data(), sp.data()+sp.size())} { }
 
+/**
+ * @brief Construct by copying from a @c std::byte array.
+ *
+ * A @c std::span is first created, then the constructor taking
+ * a @c std::span is called.
+ *
+ * @pre Size cannot be greater than the source buffer.
+ *
+ * @param buf Non-null pointer to a @c std::byte buffer of data. The 
+ * data is copied into the internal buffer of the @c mutable_shared_buffer.
+ *
+ * @param sz Size of buffer.
+ *
+ */
+  mutable_shared_buffer(const std::byte* buf, size_type sz) : 
+      mutable_shared_buffer(std::span<const std::byte>(buf, sz)) { }
+
 /**
  * @brief Move construct from a @c std::vector of @c std::bytes.
  *
@@ -174,7 +192,7 @@ class mutable_shared_buffer {
 
 /**
  * @brief Construct a @c mutable_shared_buffer with an initial size, contents
- * set to zero.
+ * of each byte set to zero.
  *
  * Allocate zero initialized space which can be overwritten with data as needed.
  * The @c data method is called to get access to the underlying @c std::byte 
@@ -186,35 +204,18 @@ class mutable_shared_buffer {
       m_data{std::make_shared<byte_vec>(sz)} { }
 
 
-/**
- * @brief Construct by copying from a @c std::byte array.
- *
- * A @c std::span is first created, then the constructor taking
- * a @c std::span is called.
- *
- * @pre Size cannot be greater than the source buffer.
- *
- * @param buf Non-null pointer to a @c std::byte buffer of data. The 
- * data is copied into the internal buffer of the @c mutable_shared_buffer.
- *
- * @param sz Size of buffer.
- *
- */
-  mutable_shared_buffer(const std::byte* buf, size_type sz) : 
-      mutable_shared_buffer(std::span<const std::byte>(buf, sz)) { }
-
 /**
  * @brief Construct by copying bytes from a @c std::span.
  *
- * The type of the span must be convertible to or layout compatible with
+ * The type of the span must be convertible to or be layout compatible with
  * @c std::byte.
  *
  * @param sp @c std::span pointing to buffer of data. The @c std::span 
  * pointer is cast into a @c std::byte pointer and bytes are then copied. 
  *
  */
-  template <typename T>
-  mutable_shared_buffer(std::span<const T> sp) : 
+  template <typename T, std::size_t Ext>
+  mutable_shared_buffer(std::span<const T, Ext> sp) : 
       mutable_shared_buffer(std::bit_cast<const std::byte *>(sp.data()), sp.size()) { }
 
 /**
@@ -350,7 +351,8 @@ class mutable_shared_buffer {
  *
  * @return Reference to @c this (to allow method chaining).
  */
-  mutable_shared_buffer& append(std::span<const std::byte> sp) {
+  template <std::size_t Ext>
+  mutable_shared_buffer& append(std::span<const std::byte, Ext> sp) {
     return append(sp.data(), sp.size());
   }
 
@@ -377,14 +379,14 @@ class mutable_shared_buffer {
  * data. In particular, this method can be used for @c char pointers, 
  * @c void pointers, @ unsigned @c char pointers, etc.
  *
- * The type of the span must be convertible to or layout compatible with
+ * The type of the span must be convertible to or be layout compatible with
  * @c std::byte.
  *
  * @param sp @c std::span of arbitrary bytes.
  *
  */
-  template <typename T>
-  mutable_shared_buffer& append(std::span<const T> sp) {
+  template <typename T, std::size_t Ext>
+  mutable_shared_buffer& append(std::span<const T, Ext> sp) {
     return append(std::bit_cast<const std::byte *>(sp.data()), sp.size());
   }
 
@@ -513,7 +515,8 @@ class const_shared_buffer {
  * copied into the internal buffer of the @c const_shared_buffer. 
  *
  */
-  explicit const_shared_buffer(std::span<const std::byte> sp) : 
+  template <std::size_t Ext>
+  explicit const_shared_buffer(std::span<const std::byte, Ext> sp) : 
       m_data(std::make_shared<byte_vec>(sp.data(), sp.data()+sp.size())) { }
 /**
  * @brief Construct by copying from a @c std::byte array.
@@ -526,7 +529,7 @@ class const_shared_buffer {
  * @param sz Size of buffer.
  */
   const_shared_buffer(const std::byte* buf, size_type sz) : 
-      const_shared_buffer(std::span<const std::byte>(buf, sz)) { }
+      const_shared_buffer(std::span<const std::byte>{buf, buf+sz}) { }
 
 /**
  * @brief Construct by copying bytes from an arbitrary pointer.
@@ -535,7 +538,7 @@ class const_shared_buffer {
  * are then copied. In particular, this method can be used for @c char pointers, 
  * @c void pointers, @c unsigned @c char pointers, etc.
  *
- * The type of the span must be convertible to or layout compatible with
+ * The type of the span must be convertible to or be layout compatible with
  * @c std::byte.
  *
  * @pre Size cannot be greater than the source buffer.

test/shared_buffer_test.cpp

@@ -46,10 +46,12 @@ void generic_pointer_append_test() {
   auto sb { generic_pointer_construction_test<chops::mutable_shared_buffer, PT>() };
   auto sav_sz { sb.size() };
   const PT arr[] { 5, 6, 7 };
-  sb.append (arr, 3);
+  const PT* ptr_arr { arr };
+  sb.append (ptr_arr, 3);
   REQUIRE (sb.size() == (sav_sz + 3));
-//  sb.append (std::span<PT>(arr, 3));
-//  REQUIRE (sb.size() == (sav_sz + 6));
+  std::span<const PT> sp { arr };
+  sb.append (sp);
+  REQUIRE (sb.size() == (sav_sz + 6));
 }
 
 template <typename SB>