diff --git a/CHANGELOG.md b/CHANGELOG.md
index e2ff7d8d..44ffd709 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -14,6 +14,7 @@ Version 200
 * Refactor buffers_suffix
 * Tidy up flat_buffer tests
 * Fix ostream prepare calculation for low limits
+* Tidy up flat_static_buffer tests
 
 API Changes:
 
diff --git a/test/beast/core/buffer_test.hpp b/test/beast/core/buffer_test.hpp
index f9f7607f..896b02b9 100644
--- a/test/beast/core/buffer_test.hpp
+++ b/test/beast/core/buffer_test.hpp
@@ -479,6 +479,56 @@ test_dynamic_buffer(
     SUITE_EXPECT(test, b0.size() == 0);
     SUITE_EXPECT(test, buffer_size(b0.data()) == 0);
 
+    // special members
+    {
+        string_view src = "Hello, world!";
+
+        DynamicBuffer b1(b0);
+        auto const mb = b1.prepare(src.size());
+        b1.commit(net::buffer_copy(mb,
+            net::const_buffer(src.data(), src.size())));
+
+        // copy constructor
+        {
+            DynamicBuffer b2(b1);
+            SUITE_EXPECT(test, b2.size() == b1.size());
+            SUITE_EXPECT(test,
+                buffers_to_string(b1.data()) ==
+                buffers_to_string(b2.data()));
+        }
+
+        // move constructor
+        {
+            DynamicBuffer b2(b1);
+            DynamicBuffer b3(std::move(b2));
+            SUITE_EXPECT(test, b3.size() == b1.size());
+            SUITE_EXPECT(test,
+                buffers_to_string(b1.data()) ==
+                buffers_to_string(b3.data()));
+        }
+
+        // copy assignment
+        {
+            DynamicBuffer b2(b0);
+            b2 = b1;
+            SUITE_EXPECT(test, b2.size() == b1.size());
+            SUITE_EXPECT(test,
+                buffers_to_string(b1.data()) ==
+                buffers_to_string(b2.data()));
+        }
+
+        // move assignment
+        {
+            DynamicBuffer b2(b1);
+            DynamicBuffer b3(b0);
+            b3 = std::move(b2);
+            SUITE_EXPECT(test, b3.size() == b1.size());
+            SUITE_EXPECT(test,
+                buffers_to_string(b1.data()) ==
+                buffers_to_string(b3.data()));
+        }
+    }
+
     // n == 0
     {
         DynamicBuffer b(b0);
diff --git a/test/beast/core/flat_buffer.cpp b/test/beast/core/flat_buffer.cpp
index 27fe821f..f3b65589 100644
--- a/test/beast/core/flat_buffer.cpp
+++ b/test/beast/core/flat_buffer.cpp
@@ -26,6 +26,9 @@ namespace beast {
 class flat_buffer_test : public beast::unit_test::suite
 {
 public:
+    BOOST_STATIC_ASSERT(
+        is_mutable_dynamic_buffer<flat_buffer>::value);
+
     void
     testDynamicBuffer()
     {
diff --git a/test/beast/core/flat_static_buffer.cpp b/test/beast/core/flat_static_buffer.cpp
index bf0c9b12..a11933c8 100644
--- a/test/beast/core/flat_static_buffer.cpp
+++ b/test/beast/core/flat_static_buffer.cpp
@@ -27,164 +27,21 @@ class flat_static_buffer_test : public beast::unit_test::suite
 {
 public:
     BOOST_STATIC_ASSERT(
-        net::is_dynamic_buffer<
-            flat_static_buffer_base>::value);
-    BOOST_STATIC_ASSERT(
-        net::is_const_buffer_sequence<
-            flat_static_buffer_base::const_buffers_type>::value);
-    BOOST_STATIC_ASSERT(
-        net::is_mutable_buffer_sequence<
-            flat_static_buffer_base::mutable_data_type>::value);
-    BOOST_STATIC_ASSERT(
-        net::is_mutable_buffer_sequence<
-            flat_static_buffer_base::mutable_buffers_type>::value);
-    BOOST_STATIC_ASSERT(std::is_convertible<
-        flat_static_buffer_base::mutable_data_type,
-        flat_static_buffer_base::const_buffers_type>::value);
+        is_mutable_dynamic_buffer<
+            flat_static_buffer<13>>::value);
 
-    template<class DynamicBuffer>
     void
-    testMutableData()
+    testDynamicBuffer()
     {
-        DynamicBuffer b;
-        DynamicBuffer const& cb = b;
-        ostream(b) << "Hello";
-        BOOST_STATIC_ASSERT(
-            net::is_const_buffer_sequence<
-                decltype(cb.data())>::value &&
-            ! net::is_mutable_buffer_sequence<
-                decltype(cb.data())>::value);
-        BOOST_STATIC_ASSERT(
-            net::is_const_buffer_sequence<
-                decltype(cb.cdata())>::value &&
-            ! net::is_mutable_buffer_sequence<
-                decltype(cb.cdata())>::value);
-        BOOST_STATIC_ASSERT(
-            net::is_mutable_buffer_sequence<
-                decltype(b.data())>::value);
-        std::for_each(
-            net::buffers_iterator<decltype(b.data())>::begin(b.data()),
-            net::buffers_iterator<decltype(b.data())>::end(b.data()),
-            [](char& c)
-            {
-                c = static_cast<char>(std::toupper(c));
-            });
-        BEAST_EXPECT(buffers_to_string(b.data()) == "HELLO");
-        BEAST_EXPECT(buffers_to_string(b.cdata()) == "HELLO");
+        flat_static_buffer<13> b;
+        test_dynamic_buffer(*this, b);
     }
 
     void
-    testStaticBuffer()
+    testMembers()
     {
-        using namespace test;
-        using net::buffer;
         using net::buffer_size;
-        char buf[12];
-        std::string const s = "Hello, world";
-        BEAST_EXPECT(s.size() == sizeof(buf));
-        for(std::size_t i = 1; i < 4; ++i) {
-        for(std::size_t j = 1; j < 4; ++j) {
-        for(std::size_t x = 1; x < 4; ++x) {
-        for(std::size_t y = 1; y < 4; ++y) {
-        for(std::size_t t = 1; t < 4; ++ t) {
-        for(std::size_t u = 1; u < 4; ++ u) {
-        std::size_t z = sizeof(buf) - (x + y);
-        std::size_t v = sizeof(buf) - (t + u);
-        {
-            std::memset(buf, 0, sizeof(buf));
-            flat_static_buffer<sizeof(buf)> ba;
-            {
-                auto d = ba.prepare(z);
-                BEAST_EXPECT(buffer_size(d) == z);
-            }
-            {
-                auto d = ba.prepare(0);
-                BEAST_EXPECT(buffer_size(d) == 0);
-            }
-            {
-                auto d = ba.prepare(y);
-                BEAST_EXPECT(buffer_size(d) == y);
-            }
-            {
-                auto d = ba.prepare(x);
-                BEAST_EXPECT(buffer_size(d) == x);
-                ba.commit(buffer_copy(d, buffer(s.data(), x)));
-            }
-            BEAST_EXPECT(ba.size() == x);
-            BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
-            {
-                auto d = ba.prepare(x);
-                BEAST_EXPECT(buffer_size(d) == x);
-            }
-            {
-                auto d = ba.prepare(0);
-                BEAST_EXPECT(buffer_size(d) == 0);
-            }
-            {
-                auto d = ba.prepare(z);
-                BEAST_EXPECT(buffer_size(d) == z);
-            }
-            {
-                auto d = ba.prepare(y);
-                BEAST_EXPECT(buffer_size(d) == y);
-                ba.commit(buffer_copy(d, buffer(s.data()+x, y)));
-            }
-            ba.commit(1);
-            BEAST_EXPECT(ba.size() == x + y);
-            BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
-            {
-                auto d = ba.prepare(x);
-                BEAST_EXPECT(buffer_size(d) == x);
-            }
-            {
-                auto d = ba.prepare(y);
-                BEAST_EXPECT(buffer_size(d) == y);
-            }
-            {
-                auto d = ba.prepare(0);
-                BEAST_EXPECT(buffer_size(d) == 0);
-            }
-            {
-                auto d = ba.prepare(z);
-                BEAST_EXPECT(buffer_size(d) == z);
-                ba.commit(buffer_copy(d, buffer(s.data()+x+y, z)));
-            }
-            ba.commit(2);
-            BEAST_EXPECT(ba.size() == x + y + z);
-            BEAST_EXPECT(buffer_size(ba.data()) == ba.size());
-            BEAST_EXPECT(buffers_to_string(ba.data()) == s);
-            ba.consume(t);
-            {
-                auto d = ba.prepare(0);
-                BEAST_EXPECT(buffer_size(d) == 0);
-            }
-            BEAST_EXPECT(buffers_to_string(ba.data()) == s.substr(t, std::string::npos));
-            ba.consume(u);
-            BEAST_EXPECT(buffers_to_string(ba.data()) == s.substr(t + u, std::string::npos));
-            ba.consume(v);
-            BEAST_EXPECT(buffers_to_string(ba.data()) == "");
-            ba.consume(1);
-            {
-                auto d = ba.prepare(0);
-                BEAST_EXPECT(buffer_size(d) == 0);
-            }
-            try
-            {
-                ba.prepare(ba.capacity() - ba.size() + 1);
-                fail();
-            }
-            catch(...)
-            {
-                pass();
-            }
-        }
-        }}}}}}
-    }
 
-    void
-    testBuffer()
-    {
-        using namespace test;
         string_view const s = "Hello, world!";
         
         // flat_static_buffer_base
@@ -193,8 +50,9 @@ public:
             flat_static_buffer_base b{buf, sizeof(buf)};
             ostream(b) << s;
             BEAST_EXPECT(buffers_to_string(b.data()) == s);
-            b.consume(b.size());
-            BEAST_EXPECT(buffers_to_string(b.data()) == "");
+            b.clear();
+            BEAST_EXPECT(b.size() == 0);
+            BEAST_EXPECT(buffer_size(b.data()) == 0);
         }
 
         // flat_static_buffer
@@ -223,9 +81,9 @@ public:
         // cause memmove
         {
             flat_static_buffer<10> b;
-            write_buffer(b, "12345");
+            ostream(b) << "12345";
             b.consume(3);
-            write_buffer(b, "67890123");
+            ostream(b) << "67890123";
             BEAST_EXPECT(buffers_to_string(b.data()) == "4567890123");
             try
             {
@@ -271,9 +129,8 @@ public:
 
     void run() override
     {
-        testBuffer();
-        testStaticBuffer();
-        testMutableData<flat_static_buffer<32>>();
+        testDynamicBuffer();
+        testMembers();
     }
 };