1 /////////////////////////////////////////////////////////////////////////////// 2 // 3 // Copyright (c) 2015 Microsoft Corporation. All rights reserved. 4 // 5 // This code is licensed under the MIT License (MIT). 6 // 7 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 8 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 9 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 10 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 11 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 12 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 13 // THE SOFTWARE. 14 // 15 /////////////////////////////////////////////////////////////////////////////// 16 17 #include <catch/catch.hpp> 18 19 #include <gsl/gsl_algorithm> 20 21 #include <array> 22 23 using namespace std; 24 using namespace gsl; 25 26 TEST_CASE("same_type") 27 { 28 // dynamic source and destination span 29 { 30 std::array<int, 5> src{1, 2, 3, 4, 5}; 31 std::array<int, 10> dst{}; 32 33 span<int> src_span(src); 34 span<int> dst_span(dst); 35 36 copy(src_span, dst_span); 37 copy(src_span, dst_span.subspan(src_span.size())); 38 39 for (std::size_t i = 0; i < src.size(); ++i) { 40 CHECK(dst[i] == src[i]); 41 CHECK(dst[i + src.size()] == src[i]); 42 } 43 } 44 45 // static source and dynamic destination span 46 { 47 std::array<int, 5> src{1, 2, 3, 4, 5}; 48 std::array<int, 10> dst{}; 49 50 span<int, 5> src_span(src); 51 span<int> dst_span(dst); 52 53 copy(src_span, dst_span); 54 copy(src_span, dst_span.subspan(src_span.size())); 55 56 for (std::size_t i = 0; i < src.size(); ++i) { 57 CHECK(dst[i] == src[i]); 58 CHECK(dst[i + src.size()] == src[i]); 59 } 60 } 61 62 // dynamic source and static destination span 63 { 64 std::array<int, 5> src{1, 2, 3, 4, 5}; 65 std::array<int, 10> dst{}; 66 67 span<int> src_span(src); 68 span<int, 10> dst_span(dst); 69 70 copy(src_span, dst_span); 71 copy(src_span, dst_span.subspan(src_span.size())); 72 73 for (std::size_t i = 0; i < src.size(); ++i) { 74 CHECK(dst[i] == src[i]); 75 CHECK(dst[i + src.size()] == src[i]); 76 } 77 } 78 79 // static source and destination span 80 { 81 std::array<int, 5> src{1, 2, 3, 4, 5}; 82 std::array<int, 10> dst{}; 83 84 span<int, 5> src_span(src); 85 span<int, 10> dst_span(dst); 86 87 copy(src_span, dst_span); 88 copy(src_span, dst_span.subspan(src_span.size())); 89 90 for (std::size_t i = 0; i < src.size(); ++i) { 91 CHECK(dst[i] == src[i]); 92 CHECK(dst[i + src.size()] == src[i]); 93 } 94 } 95 } 96 97 TEST_CASE("compatible_type") 98 { 99 // dynamic source and destination span 100 { 101 std::array<short, 5> src{1, 2, 3, 4, 5}; 102 std::array<int, 10> dst{}; 103 104 span<short> src_span(src); 105 span<int> dst_span(dst); 106 107 copy(src_span, dst_span); 108 copy(src_span, dst_span.subspan(src_span.size())); 109 110 for (std::size_t i = 0; i < src.size(); ++i) { 111 CHECK(dst[i] == src[i]); 112 CHECK(dst[i + src.size()] == src[i]); 113 } 114 } 115 116 // static source and dynamic destination span 117 { 118 std::array<short, 5> src{1, 2, 3, 4, 5}; 119 std::array<int, 10> dst{}; 120 121 span<short, 5> src_span(src); 122 span<int> dst_span(dst); 123 124 copy(src_span, dst_span); 125 copy(src_span, dst_span.subspan(src_span.size())); 126 127 for (std::size_t i = 0; i < src.size(); ++i) { 128 CHECK(dst[i] == src[i]); 129 CHECK(dst[i + src.size()] == src[i]); 130 } 131 } 132 133 // dynamic source and static destination span 134 { 135 std::array<short, 5> src{1, 2, 3, 4, 5}; 136 std::array<int, 10> dst{}; 137 138 span<short> src_span(src); 139 span<int, 10> dst_span(dst); 140 141 copy(src_span, dst_span); 142 copy(src_span, dst_span.subspan(src_span.size())); 143 144 for (std::size_t i = 0; i < src.size(); ++i) { 145 CHECK(dst[i] == src[i]); 146 CHECK(dst[i + src.size()] == src[i]); 147 } 148 } 149 150 // static source and destination span 151 { 152 std::array<short, 5> src{1, 2, 3, 4, 5}; 153 std::array<int, 10> dst{}; 154 155 span<short, 5> src_span(src); 156 span<int, 10> dst_span(dst); 157 158 copy(src_span, dst_span); 159 copy(src_span, dst_span.subspan(src_span.size())); 160 161 for (std::size_t i = 0; i < src.size(); ++i) { 162 CHECK(dst[i] == src[i]); 163 CHECK(dst[i + src.size()] == src[i]); 164 } 165 } 166 } 167 168 #ifdef CONFIRM_COMPILATION_ERRORS 169 TEST_CASE("incompatible_type") 170 { 171 std::array<int, 4> src{1, 2, 3, 4}; 172 std::array<int*, 12> dst{}; 173 174 span<int> src_span_dyn(src); 175 span<int, 4> src_span_static(src); 176 span<int*> dst_span_dyn(dst); 177 span<int*, 4> dst_span_static(dst); 178 179 // every line should produce a compilation error 180 copy(src_span_dyn, dst_span_dyn); 181 copy(src_span_dyn, dst_span_static); 182 copy(src_span_static, dst_span_dyn); 183 copy(src_span_static, dst_span_static); 184 } 185 #endif 186 187 TEST_CASE("small_destination_span") 188 { 189 std::array<int, 12> src{1, 2, 3, 4}; 190 std::array<int, 4> dst{}; 191 192 span<int> src_span_dyn(src); 193 span<int, 12> src_span_static(src); 194 span<int> dst_span_dyn(dst); 195 span<int, 4> dst_span_static(dst); 196 197 CHECK_THROWS_AS(copy(src_span_dyn, dst_span_dyn), fail_fast); 198 CHECK_THROWS_AS(copy(src_span_dyn, dst_span_static), fail_fast); 199 CHECK_THROWS_AS(copy(src_span_static, dst_span_dyn), fail_fast); 200 201 #ifdef CONFIRM_COMPILATION_ERRORS 202 copy(src_span_static, dst_span_static); 203 #endif 204 } 205