Wyatt Hepler | 023f35b | 2020-07-01 09:40:50 -0700 | [diff] [blame] | 1 | // Copyright 2019 The Pigweed Authors |
| 2 | // |
| 3 | // Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| 4 | // use this file except in compliance with the License. You may obtain a copy of |
| 5 | // the License at |
| 6 | // |
| 7 | // https://www.apache.org/licenses/LICENSE-2.0 |
| 8 | // |
| 9 | // Unless required by applicable law or agreed to in writing, software |
| 10 | // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 11 | // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| 12 | // License for the specific language governing permissions and limitations under |
| 13 | // the License. |
| 14 | |
| 15 | // Include all of the provided headers, even if they aren't tested. |
| 16 | #include <algorithm> |
| 17 | #include <array> |
| 18 | #include <cinttypes> |
| 19 | #include <cmath> |
| 20 | #include <cstdarg> |
| 21 | #include <cstddef> |
| 22 | #include <cstdint> |
| 23 | #include <cstdio> |
| 24 | #include <cstring> |
| 25 | #include <initializer_list> |
| 26 | #include <iterator> |
| 27 | #include <limits> |
| 28 | #include <new> |
| 29 | #include <string_view> |
| 30 | #include <type_traits> |
| 31 | #include <utility> |
| 32 | |
| 33 | #include "pw_preprocessor/compiler.h" |
| 34 | |
| 35 | namespace { |
| 36 | |
| 37 | // In order to test this file without dependencies on the C++ standard library, |
| 38 | // this file needs to be fully isolated from the regular Pigweed testing |
| 39 | // infrastructure. pw_unit_test's dependencies do compile with the C++ standard |
| 40 | // library, which could conflict with pw_minimal_cpp_stdlib. |
| 41 | // |
| 42 | // SimpleTest provides the basic features of pw_unit_test without dependencies. |
| 43 | class SimpleTest { |
| 44 | public: |
| 45 | virtual ~SimpleTest() = default; |
| 46 | |
| 47 | static bool RunAllTests() { |
| 48 | for (SimpleTest* test = all_tests; test != nullptr; test = test->next_) { |
| 49 | test->Run(); |
| 50 | if (!test->passed_) { |
| 51 | return false; |
| 52 | } |
| 53 | } |
| 54 | return true; |
| 55 | } |
| 56 | |
| 57 | protected: |
| 58 | SimpleTest() : next_(all_tests) { all_tests = this; } |
| 59 | |
| 60 | void RecordTestFailure() { passed_ = false; } |
| 61 | |
| 62 | private: |
| 63 | virtual void Run() = 0; |
| 64 | |
| 65 | static SimpleTest* all_tests; |
| 66 | |
| 67 | bool passed_ = true; |
| 68 | SimpleTest* next_; |
| 69 | }; |
| 70 | |
| 71 | SimpleTest* SimpleTest::all_tests = nullptr; |
| 72 | |
| 73 | #define EXPECT_EQ(lhs, rhs) \ |
| 74 | do { \ |
| 75 | if ((lhs) != (rhs)) { \ |
| 76 | RecordTestFailure(); \ |
| 77 | } \ |
| 78 | } while (0) |
| 79 | |
| 80 | #define EXPECT_TRUE(expr) EXPECT_EQ(true, expr) |
| 81 | #define EXPECT_FALSE(expr) EXPECT_EQ(false, expr) |
| 82 | #define EXPECT_STREQ(lhs, rhs) EXPECT_EQ(std::strcmp((lhs), (rhs)), 0) |
| 83 | |
| 84 | #define TEST(suite, name) \ |
| 85 | class SimpleTest_##suite##_##name : public SimpleTest { \ |
| 86 | void Run() override; \ |
| 87 | } test_##suite##_##name; \ |
| 88 | \ |
| 89 | void SimpleTest_##suite##_##name::Run() |
| 90 | |
| 91 | TEST(Algorithm, Basic) { |
| 92 | static_assert(std::min(1, 2) == 1); |
| 93 | static_assert(std::max(1, 2) == 2); |
| 94 | |
| 95 | EXPECT_EQ(std::forward<int>(2), 2); |
| 96 | } |
| 97 | |
| 98 | TEST(Algorithm, Copy) { |
| 99 | constexpr size_t kCopyOffset = 1; |
| 100 | std::array<int, 3> foo{3, 2, 1}; |
| 101 | std::array<int, 5> bar{0}; |
| 102 | |
| 103 | // Ensure zero-element iterator doesn't modify the destination object when |
| 104 | // copied. |
| 105 | int temp = foo[0]; |
| 106 | std::copy(foo.end(), foo.end(), bar.begin()); |
| 107 | EXPECT_EQ(foo[0], temp); |
| 108 | |
| 109 | // Copy a single element. |
| 110 | std::array<int, 1> one{-101}; |
| 111 | std::copy(one.begin(), one.end(), foo.begin()); |
| 112 | EXPECT_EQ(foo[0], -101); |
| 113 | |
| 114 | auto copy_end = std::copy(foo.begin(), foo.end(), bar.begin() + kCopyOffset); |
| 115 | // Verify the iterator points to the end of the copied region. |
| 116 | EXPECT_EQ(copy_end, bar.begin() + foo.size() + kCopyOffset); |
| 117 | |
| 118 | // Verify all the values were properly copied from foo to bar. |
| 119 | { |
| 120 | size_t i = 0; |
| 121 | for (auto it = bar.begin() + kCopyOffset; it != copy_end; ++it) { |
| 122 | EXPECT_EQ(*it, foo[i++]); |
| 123 | } |
| 124 | } |
| 125 | } |
| 126 | |
| 127 | TEST(Algorithm, Find) { |
| 128 | std::array<int, 5> foo{3, 2, 1, 42, 17}; |
| 129 | // Ensure a value in the middle of the array is properly found. |
| 130 | EXPECT_EQ(*std::find(std::begin(foo), std::end(foo), 42), 42); |
| 131 | |
| 132 | // Ensure the iterator returned by find() matches the expected location of the |
| 133 | // element. |
| 134 | EXPECT_EQ(std::find(std::begin(foo), std::end(foo), 42), std::begin(foo) + 3); |
| 135 | |
| 136 | // Ensure an element at the beginning of an array is found. |
| 137 | EXPECT_EQ(*std::find(std::begin(foo), std::end(foo), 3), foo[0]); |
| 138 | |
| 139 | // Ensure an element at the end of an array is found. |
| 140 | EXPECT_EQ(*std::find(std::begin(foo), std::end(foo), 17), |
| 141 | foo[foo.size() - 1]); |
| 142 | } |
| 143 | |
| 144 | TEST(Algorithm, NotFound) { |
| 145 | std::array<int, 3> foo{3, 2, 1}; |
| 146 | |
| 147 | // Ensure that if an element is not found, an iterator matching foo.end() is |
| 148 | // returned. |
| 149 | EXPECT_EQ(std::find(std::begin(foo), std::end(foo), -99), std::end(foo)); |
| 150 | |
| 151 | // Ensure that a zero-element iterator range returns the end iterator passed |
| 152 | // to std::find(). |
| 153 | EXPECT_EQ(std::find(std::end(foo), std::end(foo), 3), std::end(foo)); |
| 154 | } |
| 155 | |
| 156 | TEST(Array, Basic) { |
| 157 | constexpr std::array<int, 4> array{0, 1, 2, 3}; |
| 158 | |
| 159 | static_assert(array[2] == 2); |
| 160 | |
| 161 | for (int i = 0; i < static_cast<int>(array.size()); ++i) { |
| 162 | EXPECT_EQ(i, array[i]); |
| 163 | } |
| 164 | } |
| 165 | |
| 166 | TEST(Cmath, Basic) PW_NO_SANITIZE("float-divide-by-zero") { |
| 167 | EXPECT_EQ(std::abs(-1), 1); |
| 168 | EXPECT_EQ(std::abs(1), 1); |
| 169 | |
| 170 | // Although Clang/LLVM do not fully support __STDC_IEC_559__, they do have the |
| 171 | // necessary IEEE 754 support for floating point division by zero. |
| 172 | EXPECT_TRUE(std::isfinite(1.0)); |
| 173 | EXPECT_FALSE(std::isfinite(1.0 / 0.0)); |
| 174 | |
| 175 | EXPECT_FALSE(std::isnan(1.0)); |
| 176 | EXPECT_TRUE(std::isnan(0.0 / 0.0)); |
| 177 | |
| 178 | EXPECT_FALSE(std::signbit(1.0)); |
| 179 | EXPECT_TRUE(std::signbit(-1.0)); |
| 180 | } |
| 181 | |
| 182 | TEST(Cstddef, Basic) { |
| 183 | using std::byte; |
| 184 | byte foo = byte{12}; |
| 185 | EXPECT_EQ(foo, byte{12}); |
| 186 | } |
| 187 | |
| 188 | TEST(Iterator, Basic) { |
| 189 | std::array<int, 3> foo{3, 2, 1}; |
| 190 | |
| 191 | EXPECT_EQ(std::data(foo), foo.data()); |
| 192 | EXPECT_EQ(std::size(foo), foo.size()); |
| 193 | |
| 194 | EXPECT_EQ(*std::begin(foo), foo[0]); |
| 195 | EXPECT_EQ(std::end(foo), std::begin(foo) + foo.size()); |
| 196 | |
| 197 | foo.fill(99); |
| 198 | EXPECT_EQ(foo[0], 99); |
| 199 | EXPECT_EQ(foo[1], 99); |
| 200 | EXPECT_EQ(foo[2], 99); |
| 201 | } |
| 202 | |
| 203 | template <typename T> |
| 204 | int SumFromInitializerList(std::initializer_list<T> values) { |
| 205 | int sum = 0; |
| 206 | for (auto value : values) { |
| 207 | sum += value; |
| 208 | } |
| 209 | return sum; |
| 210 | } |
| 211 | TEST(InitializerList, Empty) { |
| 212 | std::initializer_list<int> mt; |
| 213 | EXPECT_EQ(0, SumFromInitializerList(mt)); |
| 214 | |
| 215 | EXPECT_EQ(0, SumFromInitializerList<float>({})); |
| 216 | } |
| 217 | |
| 218 | TEST(InitializerList, Declared) { |
| 219 | std::initializer_list<char> list{'\3', '\3', '\4'}; |
| 220 | EXPECT_EQ(10, SumFromInitializerList(list)); |
| 221 | } |
| 222 | |
| 223 | TEST(InitializerList, Inline) { |
| 224 | EXPECT_EQ(42, SumFromInitializerList<long>({42})); |
| 225 | EXPECT_EQ(2, SumFromInitializerList<bool>({true, false, true})); |
| 226 | EXPECT_EQ(15, SumFromInitializerList({1, 2, 3, 4, 5})); |
| 227 | } |
| 228 | |
| 229 | TEST(Limits, Basic) { |
| 230 | static_assert(std::numeric_limits<unsigned char>::is_specialized); |
| 231 | static_assert(std::numeric_limits<unsigned char>::is_integer); |
| 232 | static_assert(std::numeric_limits<unsigned char>::min() == 0u); |
| 233 | static_assert(std::numeric_limits<unsigned char>::max() == 255u); |
| 234 | |
| 235 | static_assert(std::numeric_limits<signed char>::is_specialized); |
| 236 | static_assert(std::numeric_limits<signed char>::is_integer); |
| 237 | static_assert(std::numeric_limits<signed char>::min() == -128); |
| 238 | static_assert(std::numeric_limits<signed char>::max() == 127); |
| 239 | |
| 240 | // Assume 64-bit long long |
| 241 | static_assert(std::numeric_limits<long long>::is_specialized); |
| 242 | static_assert(std::numeric_limits<long long>::is_integer); |
| 243 | static_assert(std::numeric_limits<long long>::min() == |
| 244 | (-9223372036854775807ll - 1)); |
| 245 | static_assert(std::numeric_limits<long long>::max() == 9223372036854775807ll); |
| 246 | |
| 247 | static_assert(std::numeric_limits<unsigned long long>::is_specialized); |
| 248 | static_assert(std::numeric_limits<unsigned long long>::is_integer); |
| 249 | static_assert(std::numeric_limits<unsigned long long>::min() == 0u); |
| 250 | static_assert(std::numeric_limits<unsigned long long>::max() == |
| 251 | 18446744073709551615ull); |
| 252 | } |
| 253 | |
| 254 | TEST(New, PlacementNew) { |
Prashanth Swaminathan | be29ad9 | 2021-02-02 22:16:29 -0800 | [diff] [blame] | 255 | alignas(sizeof(int)) unsigned char value[sizeof(int)]; |
Wyatt Hepler | 023f35b | 2020-07-01 09:40:50 -0700 | [diff] [blame] | 256 | new (value) int(1234); |
| 257 | |
| 258 | int int_value; |
| 259 | std::memcpy(&int_value, value, sizeof(int_value)); |
| 260 | EXPECT_EQ(1234, int_value); |
| 261 | } |
| 262 | |
| 263 | TEST(New, Launder) { |
| 264 | unsigned char value[4]; |
| 265 | int* int_ptr = std::launder(reinterpret_cast<int*>(value)); |
| 266 | EXPECT_EQ(static_cast<void*>(int_ptr), static_cast<void*>(value)); |
| 267 | } |
| 268 | |
| 269 | TEST(StringView, Basic) { |
| 270 | constexpr std::string_view value("1234567890"); |
| 271 | static_assert(value.size() == 10); |
| 272 | static_assert(value[1] == '2'); |
| 273 | |
| 274 | char buffer[] = "!!!!!"; |
| 275 | constexpr size_t buffer_size = sizeof(buffer) - 1; // always keep the \0 |
| 276 | |
| 277 | value.copy(buffer, buffer_size, 10); |
| 278 | EXPECT_STREQ(buffer, "!!!!!"); |
| 279 | |
| 280 | value.copy(buffer, buffer_size, 9); |
| 281 | EXPECT_STREQ(buffer, "0!!!!"); |
| 282 | |
| 283 | value.copy(buffer, buffer_size, 2); |
| 284 | EXPECT_STREQ(buffer, "34567"); |
| 285 | |
| 286 | value.copy(buffer, buffer_size); |
| 287 | EXPECT_STREQ(buffer, "12345"); |
| 288 | } |
| 289 | |
| 290 | TEST(TypeTraits, Basic) { |
| 291 | static_assert(std::is_integral_v<bool>); |
| 292 | static_assert(!std::is_integral_v<float>); |
| 293 | |
| 294 | static_assert(std::is_floating_point_v<float>); |
| 295 | static_assert(!std::is_floating_point_v<bool>); |
| 296 | |
| 297 | static_assert(std::is_same_v<float, float>); |
| 298 | static_assert(!std::is_same_v<char, unsigned char>); |
| 299 | } |
| 300 | |
| 301 | struct MoveTester { |
| 302 | MoveTester(int value) : magic_value(value), moved(false) {} |
| 303 | |
| 304 | MoveTester(const MoveTester&) = default; |
| 305 | |
| 306 | MoveTester(MoveTester&& other) : magic_value(other.magic_value), moved(true) { |
| 307 | other.magic_value = 0xffff; |
| 308 | } |
| 309 | |
| 310 | int magic_value; |
| 311 | bool moved; |
| 312 | }; |
| 313 | |
| 314 | TEST(Utility, Move) { |
| 315 | MoveTester test(123); |
| 316 | |
| 317 | MoveTester copied(test); |
| 318 | EXPECT_EQ(copied.magic_value, 123); |
| 319 | EXPECT_FALSE(copied.moved); |
| 320 | |
| 321 | MoveTester moved(std::move(copied)); |
| 322 | EXPECT_EQ(123, moved.magic_value); |
| 323 | EXPECT_EQ(0xffff, copied.magic_value); |
| 324 | EXPECT_TRUE(moved.moved); |
| 325 | } |
| 326 | |
| 327 | } // namespace |
| 328 | |
| 329 | namespace pw::minimal_cpp_stdlib { |
| 330 | |
| 331 | bool RunAllTests() { return SimpleTest::RunAllTests(); } |
| 332 | |
| 333 | } // namespace pw::minimal_cpp_stdlib |