C++20 support for windows (#7)

Added Visual Studio support (Visual Studio 2019 16.10.0)
yax-lakam-tuun · May 27, 2021 · 77987b4 · 77987b4
1 parent c0095d1
commit 77987b4
Show file tree

Hide file tree

Showing 27 changed files with 108 additions and 91 deletions.
diff --git a/README.md b/README.md
@@ -90,9 +90,11 @@ int main()
 
 # Requirements
 * C++20 compiler and standard library
-* gcc10 and libstdc++-10-dev or higher (see Dockerfile)
-* Not supported currently: Windows and macOS (due to lack of C++20 features)
-  * Support will be added in the future
+* Supported:
+   * gcc10 and libstdc++-10-dev or higher (see [`test/linux.Dockerfile`](test/linux.Dockerfile))
+   * msvc: Visual Studio 2019 16.10.0 (see [`test/win.Dockerfile`](test/win.Dockerfile))
+* Not supported: 
+  * macOS (due to lack of C++20 features), support will be added in the future
 
 # CI builds
 CI builds usually consists of a test build and a conan demo build. 

diff --git a/include/qrcode/code/bit_view.h b/include/qrcode/code/bit_view.h
@@ -240,7 +240,7 @@ namespace qrcode::code::test
 
             auto const range = bit_view{some_bytes};
 
-            return std::ranges::equal(range, std::array{1,1,0,0,0,1,1,1,  0,1,0,1,1,0,0,1});
+            return std::ranges::equal(range, std::array<bool,16>{1,1,0,0,0,1,1,1,  0,1,0,1,1,0,0,1});
         };
         static_assert(f());
     }
@@ -253,7 +253,7 @@ namespace qrcode::code::test
 
             auto const range = some_bytes | views::bit;
 
-            return std::ranges::equal(range, std::array{1,1,0,0,0,1,1,1,  0,1,0,1,1,0,0,1});
+            return std::ranges::equal(range, std::array<bool,16>{1,1,0,0,0,1,1,1,  0,1,0,1,1,0,0,1});
         };
         static_assert(f());
     }
@@ -268,7 +268,7 @@ namespace qrcode::code::test
                 | views::bit 
                 | std::views::transform([](auto v) { return !v; });
 
-            return std::ranges::equal(range, std::array{0,0,1,1,1,0,0,0,  1,0,1,0,0,1,1,0});
+            return std::ranges::equal(range, std::array<bool,16>{0,0,1,1,1,0,0,0,  1,0,1,0,0,1,1,0});
         };
         static_assert(f());
     }

diff --git a/include/qrcode/code/lfsr.h b/include/qrcode/code/lfsr.h
@@ -52,7 +52,7 @@ namespace qrcode::code
         {
             using qrcode::code::detail::msb_index;
             auto const last_bit = state >> (msb_index(generator)-1);
-            state = ((state << 1) | bit) ^ (last_bit * generator);
+            state = ((state << 1) | static_cast<T>(bit)) ^ (last_bit * generator);
         }
 
         [[nodiscard]] friend constexpr auto state(lfsr const& instance) noexcept

diff --git a/include/qrcode/data/alphanumeric_encoder.h b/include/qrcode/data/alphanumeric_encoder.h
@@ -24,6 +24,7 @@
 #pragma once
 
 #include <ranges>
+#include <cassert>
 
 #include <qrcode/data/alphanumeric_encoding.h>
 #include <qrcode/data/bit_stream.h>
@@ -96,7 +97,7 @@ namespace qrcode::data::test
 
             return std::ranges::equal(
                 stream.get(),
-                std::array{
+                std::array<bool,69>{
                     1,0,1,  // mode
                     0,1,0,1,1, // count = 11
                     0,1,1,0,0,0,0,1,0,1,1, 0,1,1,1,1,0,0,0,1,1,0, 1,0,0,0,1,0,1,1,1,0,0, 
@@ -126,7 +127,7 @@ namespace qrcode::data::test
 
             return std::ranges::equal(
                 stream.get(),
-                std::array{
+                std::array<bool,69>{
                     1,0,1,  // mode
                     0,1,0,1,1, // count = 11
                     0,1,1,0,0,0,0,1,0,1,1, 0,1,1,1,1,0,0,0,1,1,0, 1,0,0,0,1,0,1,1,1,0,0, 

diff --git a/include/qrcode/data/alphanumeric_encoding.h b/include/qrcode/data/alphanumeric_encoding.h
@@ -115,13 +115,13 @@ namespace qrcode::data::detail::test
 
         using a = alphanumeric;
 
-        static_assert(std::ranges::equal(f(a::code_0, a::code_0), std::array{0,0,0,0,0,0,0,0,0,0,0}));
-        static_assert(std::ranges::equal(f(a::code_0, a::code_1), std::array{0,0,0,0,0,0,0,0,0,0,1}));
-        static_assert(std::ranges::equal(f(a::code_0, a::code_2), std::array{0,0,0,0,0,0,0,0,0,1,0}));
-        static_assert(std::ranges::equal(f(a::code_0, a::code_A), std::array{0,0,0,0,0,0,0,1,0,1,0}));
-        static_assert(std::ranges::equal(f(a::code_1, a::code_A), std::array{0,0,0,0,0,1,1,0,1,1,1}));
-        static_assert(std::ranges::equal(f(a::code_2, a::code_A), std::array{0,0,0,0,1,1,0,0,1,0,0}));
-        static_assert(std::ranges::equal(f(a::code_Z, a::code_B), std::array{1,1,0,0,0,1,1,0,0,1,0}));
+        static_assert(std::ranges::equal(f(a::code_0, a::code_0), std::array<bool,11>{0,0,0,0,0,0,0,0,0,0,0}));
+        static_assert(std::ranges::equal(f(a::code_0, a::code_1), std::array<bool,11>{0,0,0,0,0,0,0,0,0,0,1}));
+        static_assert(std::ranges::equal(f(a::code_0, a::code_2), std::array<bool,11>{0,0,0,0,0,0,0,0,0,1,0}));
+        static_assert(std::ranges::equal(f(a::code_0, a::code_A), std::array<bool,11>{0,0,0,0,0,0,0,1,0,1,0}));
+        static_assert(std::ranges::equal(f(a::code_1, a::code_A), std::array<bool,11>{0,0,0,0,0,1,1,0,1,1,1}));
+        static_assert(std::ranges::equal(f(a::code_2, a::code_A), std::array<bool,11>{0,0,0,0,1,1,0,0,1,0,0}));
+        static_assert(std::ranges::equal(f(a::code_Z, a::code_B), std::array<bool,11>{1,1,0,0,0,1,1,0,0,1,0}));
     }
 
     constexpr auto single_alphanumeric_encodes_given_alphanummeric_as_six_bits()
@@ -136,13 +136,13 @@ namespace qrcode::data::detail::test
         };
 
         using a = alphanumeric;
-        static_assert(std::ranges::equal(f(a::code_0), std::array{0,0,0,0,0,0}));
-        static_assert(std::ranges::equal(f(a::code_1), std::array{0,0,0,0,0,1}));
-        static_assert(std::ranges::equal(f(a::code_2), std::array{0,0,0,0,1,0}));
-        static_assert(std::ranges::equal(f(a::code_A), std::array{0,0,1,0,1,0}));
-        static_assert(std::ranges::equal(f(a::code_asterisk), std::array{1,0,0,1,1,1}));
-        static_assert(std::ranges::equal(f(a::code_percent), std::array{1,0,0,1,1,0}));
-        static_assert(std::ranges::equal(f(a::code_dollar), std::array{1,0,0,1,0,1}));
+        static_assert(std::ranges::equal(f(a::code_0), std::array<bool,6>{0,0,0,0,0,0}));
+        static_assert(std::ranges::equal(f(a::code_1), std::array<bool,6>{0,0,0,0,0,1}));
+        static_assert(std::ranges::equal(f(a::code_2), std::array<bool,6>{0,0,0,0,1,0}));
+        static_assert(std::ranges::equal(f(a::code_A), std::array<bool,6>{0,0,1,0,1,0}));
+        static_assert(std::ranges::equal(f(a::code_asterisk), std::array<bool,6>{1,0,0,1,1,1}));
+        static_assert(std::ranges::equal(f(a::code_percent), std::array<bool,6>{1,0,0,1,1,0}));
+        static_assert(std::ranges::equal(f(a::code_dollar), std::array<bool,6>{1,0,0,1,0,1}));
     }
 }
 
@@ -160,7 +160,7 @@ namespace qrcode::data::test
 
             return std::ranges::equal(
                 stream.get(), 
-                std::array{0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,1,1,1,1,1,0,0,0,1,1,0,0,1,0});
+                std::array<bool,33>{0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,1,1,1,1,1,0,0,0,1,1,0,0,1,0});
         };
         static_assert(f());
     }
@@ -175,7 +175,8 @@ namespace qrcode::data::test
             encode_alphanumerics(stream, std::array{a::code_0, a::code_1,a::code_1, a::code_A,a::code_Z}); 
 
             return std::ranges::equal(
-                stream.get(), std::array{0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,1,1,1,1,0,0,0,1,1});
+                stream.get(), 
+                std::array<bool,28>{0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,1,0,1,1,1,1,0,0,0,1,1});
         };
         static_assert(f());
     }
@@ -191,7 +192,8 @@ namespace qrcode::data::test
                 stream, std::array{a::code_A, a::code_C,a::code_minus, a::code_4,a::code_2}); 
 
             return std::ranges::equal(
-                stream.get(), std::array{0,0,1,1,1,0,0,1,1,1,0,1,1,1,0,0,1,1,1,0,0,1,0,0,0,0,1,0});
+                stream.get(), 
+                std::array<bool,28>{0,0,1,1,1,0,0,1,1,1,0,1,1,1,0,0,1,1,1,0,0,1,0,0,0,0,1,0});
         };
         static_assert(f());
     }

diff --git a/include/qrcode/data/bit_stream.h b/include/qrcode/data/bit_stream.h
@@ -80,12 +80,12 @@ namespace qrcode::data::test
     constexpr auto bit_streams_accept_integers_with_their_bit_count_and_convert_it_to_a_binary_stream_msb_first()
     {
         static_assert(std::ranges::equal(bit_stream{}.add(0, 0_bits).get(), std::array<bool,0>{}));
-        static_assert(std::ranges::equal(bit_stream{}.add(0b0, 1_bits).get(), std::array{0}));
-        static_assert(std::ranges::equal(bit_stream{}.add(0b1, 1_bits).get(), std::array{1}));
-        static_assert(std::ranges::equal(bit_stream{}.add(0b10, 2_bits).get(), std::array{1,0}));
-        static_assert(std::ranges::equal(bit_stream{}.add(0b110, 3_bits).get(), std::array{1,1,0}));
-        static_assert(std::ranges::equal(bit_stream{}.add(0b110, 3_bits).add(0b00010, 5_bits).get(), std::array{1,1,0,0,0,0,1,0}));
-        static_assert(std::ranges::equal(bit_stream{}.add(6, 16_bits).get(), std::array{0,0,0,0,  0,0,0,0,  0,0,0,0,  0,1,1,0}));
+        static_assert(std::ranges::equal(bit_stream{}.add(0b0, 1_bits).get(), std::array<bool,1>{0}));
+        static_assert(std::ranges::equal(bit_stream{}.add(0b1, 1_bits).get(), std::array<bool,1>{1}));
+        static_assert(std::ranges::equal(bit_stream{}.add(0b10, 2_bits).get(), std::array<bool,2>{1,0}));
+        static_assert(std::ranges::equal(bit_stream{}.add(0b110, 3_bits).get(), std::array<bool,3>{1,1,0}));
+        static_assert(std::ranges::equal(bit_stream{}.add(0b110, 3_bits).add(0b00010, 5_bits).get(), std::array<bool,8>{1,1,0,0,0,0,1,0}));
+        static_assert(std::ranges::equal(bit_stream{}.add(6, 16_bits).get(), std::array<bool,16>{0,0,0,0,  0,0,0,0,  0,0,0,0,  0,1,1,0}));
     }
 
     constexpr auto bit_streams_have_a_size()

diff --git a/include/qrcode/data/byte_encoder.h b/include/qrcode/data/byte_encoder.h
@@ -106,7 +106,7 @@ namespace qrcode::data::detail::test
 
             return std::ranges::equal(
                 stream.get(), 
-                std::array{
+                std::array<bool, 21>{
                     1,1, // mode
                     0,1,0, // count
                     0,0,0,0,0,0,0,1,  0,0,0,0,0,0,1,0

diff --git a/include/qrcode/data/indicator.h b/include/qrcode/data/indicator.h
@@ -66,7 +66,7 @@ namespace qrcode::data::test
 
             encode(stream, any_mode_indicator);
 
-            return std::ranges::equal(stream.get(), std::array{0,0,0,1,0});
+            return std::ranges::equal(stream.get(), std::array<bool,5>{0,0,0,1,0});
         };
         static_assert(f());
     }
@@ -81,7 +81,7 @@ namespace qrcode::data::test
 
             encode(stream, any_count_indicator, any_count);
 
-            return std::ranges::equal(stream.get(), std::array{0,0,1,0,0,1,0,0,1,1});
+            return std::ranges::equal(stream.get(), std::array<bool,10>{0,0,1,0,0,1,0,0,1,1});
         };
         static_assert(f());
     }

diff --git a/include/qrcode/data/kanji_encoder.h b/include/qrcode/data/kanji_encoder.h
@@ -81,7 +81,7 @@ namespace qrcode::data::test
 
             return std::ranges::equal(
                 stream.get(), 
-                std::array{
+                std::array<bool,34>{
                     1,0,1, // mode
                     0,0,0,1,0, // count                         
                     0,1,1,0,1,1,0,0,1,1,1,1,1, 1,1,0,1,0,1,0,1,0,1,0,1,0

diff --git a/include/qrcode/data/kanji_encoding.h b/include/qrcode/data/kanji_encoding.h
@@ -24,6 +24,7 @@
 #pragma once
 
 #include <ranges>
+#include <cassert>
 
 #include <qrcode/data/bit_stream.h>
 #include <qrcode/data/kanji.h>
@@ -74,7 +75,6 @@ namespace qrcode::data
 }
 
 #ifdef QRCODE_TESTS_ENABLED
-
 namespace qrcode::data::detail::test
 {
     constexpr auto kanjis_can_be_added_to_a_given_bit_stream_as_13_bit_representation()
@@ -85,7 +85,7 @@ namespace qrcode::data::detail::test
 
             encode(stream, kanji{0xD9Fu});
 
-            return std::ranges::equal(stream.get(), std::array{0,1,1,0,1,1,0,0,1,1,1,1,1});
+            return std::ranges::equal(stream.get(), std::array<bool,13>{0,1,1,0,1,1,0,0,1,1,1,1,1});
         };
         static_assert(f());
     }
@@ -116,7 +116,7 @@ namespace qrcode::data::test
             encode_kanjis(stream, std::array{0x93u, 0x5Fu, 0xE4u, 0xAAu});
 
             return std::ranges::equal(
-                stream.get(), std::array{0,1,1,0,1,1,0,0,1,1,1,1,1, 1,1,0,1,0,1,0,1,0,1,0,1,0});
+                stream.get(), std::array<bool,26>{0,1,1,0,1,1,0,0,1,1,1,1,1, 1,1,0,1,0,1,0,1,0,1,0,1,0});
         };
         static_assert(f());
     }
@@ -146,7 +146,7 @@ namespace qrcode::data::test
 
             return std::ranges::equal(
                 stream.get(), 
-                std::array{0,1,1,0,1,1,0,0,1,1,1,1,1, 1,1,0,1,0,1,0,1,0,1,0,1,0}
+                std::array<bool,26>{0,1,1,0,1,1,0,0,1,1,1,1,1, 1,1,0,1,0,1,0,1,0,1,0,1,0}
             );
         };
         static_assert(f());

diff --git a/include/qrcode/data/numeric_encoder.h b/include/qrcode/data/numeric_encoder.h
@@ -24,6 +24,7 @@
 #pragma once
 
 #include <ranges>
+#include <cassert>
 
 #include <qrcode/data/bit_stream.h>
 #include <qrcode/data/numeric_encoding.h>
@@ -109,7 +110,7 @@ namespace qrcode::data::test
 
             return std::ranges::equal(
                 stream.get(),
-                std::array{
+                std::array<bool,36>{
                     0,1,0,1, // mode
                     0,1,0,0,0, // count
                     0,0,0,0,0,0,1,1,0,0, 0,1,0,1,0,1,1,0,0,1, 1,0,0,0,0,1,1
@@ -139,7 +140,7 @@ namespace qrcode::data::test
 
             return std::ranges::equal(
                 stream.get(),
-                std::array{
+                std::array<bool,63>{
                     0,1,0,1, // mode
                     1,0,0,0,0, // count = 16
                     0,0,0,0,0,0,1,1,0,0, 0,1,0,1,0,1,1,0,0,1, 1,0,1,0,1,0,0,1,1,0, 

diff --git a/include/qrcode/data/numeric_encoding.h b/include/qrcode/data/numeric_encoding.h
@@ -140,11 +140,11 @@ namespace qrcode::data::detail::test
 
         using n = numeric;
 
-        static_assert(std::ranges::equal(f(n::n0,n::n1,n::n2), std::array{0,0,0,0,0,0,1,1,0,0}));
-        static_assert(std::ranges::equal(f(n::n3,n::n4,n::n5), std::array{0,1,0,1,0,1,1,0,0,1}));
-        static_assert(std::ranges::equal(f(n::n0,n::n1,n::n2,n::n3,n::n4,n::n5), std::array{0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,0,0,1}));
-        static_assert(std::ranges::equal(f(n::n6), std::array{0,1,1,0}));
-        static_assert(std::ranges::equal(f(n::n8,n::n2), std::array{1,0,1,0,0,1,0}));
+        static_assert(std::ranges::equal(f(n::n0,n::n1,n::n2), std::array<bool,10>{0,0,0,0,0,0,1,1,0,0}));
+        static_assert(std::ranges::equal(f(n::n3,n::n4,n::n5), std::array<bool,10>{0,1,0,1,0,1,1,0,0,1}));
+        static_assert(std::ranges::equal(f(n::n0,n::n1,n::n2,n::n3,n::n4,n::n5), std::array<bool,20>{0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1,1,0,0,1}));
+        static_assert(std::ranges::equal(f(n::n6), std::array<bool,4>{0,1,1,0}));
+        static_assert(std::ranges::equal(f(n::n8,n::n2), std::array<bool,7>{1,0,1,0,0,1,0}));
     }
 
     constexpr auto encode_numerics_groups_three_digits_to_one_number_and_converts_these_groups_to_their_bitwise_representation()
@@ -159,9 +159,9 @@ namespace qrcode::data::detail::test
         };
 
         using n = numeric;
-        static_assert(std::ranges::equal(f(std::array{n::n0,n::n1,n::n2}), std::array{0,0,0,0,0,0,1,1,0,0}));
-        static_assert(std::ranges::equal(f(std::array{n::n3,n::n4,n::n5}), std::array{0,1,0,1,0,1,1,0,0,1}));
-        static_assert(std::ranges::equal(f(std::array{n::n0,n::n1,n::n2,n::n3,n::n4,n::n5}), std::array{0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,1,1,0,0,1}));
+        static_assert(std::ranges::equal(f(std::array{n::n0,n::n1,n::n2}), std::array<bool,10>{0,0,0,0,0,0,1,1,0,0}));
+        static_assert(std::ranges::equal(f(std::array{n::n3,n::n4,n::n5}), std::array<bool,10>{0,1,0,1,0,1,1,0,0,1}));
+        static_assert(std::ranges::equal(f(std::array{n::n0,n::n1,n::n2,n::n3,n::n4,n::n5}), std::array<bool,20>{0,0,0,0,0,0,1,1,0,0,0,1,0,1,0,1,1,0,0,1}));
     }    
 }
 
@@ -180,11 +180,11 @@ namespace qrcode::data::test
 
         using n = numeric;
 
-        static_assert(std::ranges::equal(f(std::array{n::n6}), std::array{0,1,1,0}));
-        static_assert(std::ranges::equal(f(std::array{n::n8,n::n2}), std::array{1,0,1,0,0,1,0}));
-        static_assert(std::ranges::equal(f(std::array{n::n8,n::n2,n::n1,n::n3}), std::array{1,1,0,0,1,1,0,1,0,1,0,0,1,1}));
-        static_assert(std::ranges::equal(f(std::array{n::n8,n::n2,n::n1,n::n3,n::n4}), std::array{1,1,0,0,1,1,0,1,0,1,0,1,0,0,0,1,0}));
-        static_assert(std::ranges::equal(f(std::array{n::n8,n::n6,n::n7,n::n5,n::n3,n::n0,n::n9}), std::array{1,1,0,1,1,0,0,0,1,1,1,0,0,0,0,1,0,0,1,0,1,0,0,1}));
+        static_assert(std::ranges::equal(f(std::array{n::n6}), std::array<bool,4>{0,1,1,0}));
+        static_assert(std::ranges::equal(f(std::array{n::n8,n::n2}), std::array<bool,7>{1,0,1,0,0,1,0}));
+        static_assert(std::ranges::equal(f(std::array{n::n8,n::n2,n::n1,n::n3}), std::array<bool,14>{1,1,0,0,1,1,0,1,0,1,0,0,1,1}));
+        static_assert(std::ranges::equal(f(std::array{n::n8,n::n2,n::n1,n::n3,n::n4}), std::array<bool,17>{1,1,0,0,1,1,0,1,0,1,0,1,0,0,0,1,0}));
+        static_assert(std::ranges::equal(f(std::array{n::n8,n::n6,n::n7,n::n5,n::n3,n::n0,n::n9}), std::array<bool,24>{1,1,0,1,1,0,0,0,1,1,1,0,0,0,0,1,0,0,1,0,1,0,0,1}));
     }
 
     constexpr auto numeric_character_count_returns_the_number_of_characters_which_can_be_encoded_from_given_message()

diff --git a/include/qrcode/eci/assignment_number.h b/include/qrcode/eci/assignment_number.h
@@ -87,32 +87,32 @@ namespace qrcode::eci::test
     {
         static_assert(std::ranges::equal(
             encode_wrapper(assignment_number{0}).get(), 
-            std::array{0,0,0,0,0,0,0,0}
+            std::array<bool,8>{0,0,0,0,0,0,0,0}
         ));
 
         static_assert(std::ranges::equal(
             encode_wrapper(assignment_number{127}).get(), 
-            std::array{0,1,1,1,1,1,1,1}
+            std::array<bool,8>{0,1,1,1,1,1,1,1}
         ));
 
         static_assert(std::ranges::equal(
             encode_wrapper(assignment_number{128}).get(), 
-            std::array{1,0, 0,0,0,0,0,0,  1,0,0,0,0,0,0,0}
+            std::array<bool,16>{1,0, 0,0,0,0,0,0,  1,0,0,0,0,0,0,0}
         ));
 
         static_assert(std::ranges::equal(
             encode_wrapper(assignment_number{16383}).get(), 
-            std::array{1,0, 1,1,1,1,1,1,  1,1,1,1,1,1,1,1}
+            std::array<bool,16>{1,0, 1,1,1,1,1,1,  1,1,1,1,1,1,1,1}
         ));
 
         static_assert(std::ranges::equal(
             encode_wrapper(assignment_number{16384}).get(), 
-            std::array{1,1,0, 0,0,0,0,0,  0,1,0,0,0,0,0,0,  0,0,0,0,0,0,0,0}
+            std::array<bool,24>{1,1,0, 0,0,0,0,0,  0,1,0,0,0,0,0,0,  0,0,0,0,0,0,0,0}
         ));
 
         static_assert(std::ranges::equal(
             encode_wrapper(assignment_number{999999}).get(), 
-            std::array{1,1,0, 0,1,1,1,1,  0,1,0,0,0,0,1,0,  0,0,1,1,1,1,1,1}
+            std::array<bool,24>{1,1,0, 0,1,1,1,1,  0,1,0,0,0,0,1,0,  0,0,1,1,1,1,1,1}
         ));
     }
 

diff --git a/include/qrcode/eci/message_header.h b/include/qrcode/eci/message_header.h
@@ -55,12 +55,12 @@ namespace qrcode::eci::test
     {
         static_assert(std::ranges::equal(
             encode_wrapper(message_header{assignment_number{0}}).get(), 
-            std::array{0,1,1,1,  0,0,0,0,0,0,0,0}
+            std::array<bool,12>{0,1,1,1,  0,0,0,0,0,0,0,0}
         ));
 
         static_assert(std::ranges::equal(
             encode_wrapper(message_header{128}).get(), 
-            std::array{0,1,1,1,  1,0,0,0,0,0,0,0,  1,0,0,0,0,0,0,0}
+            std::array<bool,20>{0,1,1,1,  1,0,0,0,0,0,0,0,  1,0,0,0,0,0,0,0}
         ));
     }
 

diff --git a/include/qrcode/micro_qr/code_bits.h b/include/qrcode/micro_qr/code_bits.h
@@ -114,7 +114,7 @@ namespace qrcode::micro_qr::test
 
         static_assert(std::ranges::equal(
             code_bits(any_data, any_capacity),
-            std::array{
+            std::array<bool,80>{
                 0,1,0,0,0,0,0,0, 0,0,0,1,1,0,0,0, 1,0,1,0,1,1,0,0, 1,1,0,0,0,0,1,1, 0,0,0,0,0,0,0,0,
                 1,0,0,0,0,1,1,0, 0,0,0,0,1,1,0,1, 0,0,1,0,0,0,1,0, 1,0,1,0,1,1,1,0, 0,0,1,1,0,0,0,0
             }