TestIntegerRange.cpp (5455B)
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */ 3 /* This Source Code Form is subject to the terms of the Mozilla Public 4 * License, v. 2.0. If a copy of the MPL was not distributed with this 5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 6 7 #include "mozilla/Assertions.h" 8 #include "mozilla/IntegerRange.h" 9 10 #include <stddef.h> 11 12 using mozilla::IntegerRange; 13 using mozilla::Reversed; 14 15 const size_t kMaxNumber = 50; 16 const size_t kArraySize = 256; 17 18 template <typename IntType> 19 static IntType GenerateNumber() { 20 return static_cast<IntType>(rand() % kMaxNumber + 1); 21 } 22 23 template <typename IntType> 24 static void TestSingleParamRange(const IntType aN) { 25 IntType array[kArraySize]; 26 IntType* ptr = array; 27 for (auto i : IntegerRange(aN)) { 28 static_assert(std::is_same_v<decltype(i), IntType>, 29 "type of the loop var and the param should be the same"); 30 *ptr++ = i; 31 } 32 33 MOZ_RELEASE_ASSERT(ptr - array == static_cast<ptrdiff_t>(aN), 34 "Should iterates N items"); 35 for (size_t i = 0; i < static_cast<size_t>(aN); i++) { 36 MOZ_RELEASE_ASSERT(array[i] == static_cast<IntType>(i), 37 "Values should equal to the index"); 38 } 39 } 40 41 template <typename IntType> 42 static void TestSingleParamReverseRange(const IntType aN) { 43 IntType array[kArraySize]; 44 IntType* ptr = array; 45 for (auto i : Reversed(IntegerRange(aN))) { 46 static_assert(std::is_same_v<decltype(i), IntType>, 47 "type of the loop var and the param should be the same"); 48 *ptr++ = i; 49 } 50 51 MOZ_RELEASE_ASSERT(ptr - array == static_cast<ptrdiff_t>(aN), 52 "Should iterates N items"); 53 for (size_t i = 0; i < static_cast<size_t>(aN); i++) { 54 MOZ_RELEASE_ASSERT(array[i] == static_cast<IntType>(aN - i - 1), 55 "Values should be the reverse of their index"); 56 } 57 } 58 59 template <typename IntType> 60 static void TestSingleParamIntegerRange() { 61 const auto kN = GenerateNumber<IntType>(); 62 TestSingleParamRange<IntType>(0); 63 TestSingleParamReverseRange<IntType>(0); 64 TestSingleParamRange<IntType>(kN); 65 TestSingleParamReverseRange<IntType>(kN); 66 } 67 68 template <typename IntType1, typename IntType2> 69 static void TestDoubleParamRange(const IntType1 aBegin, const IntType2 aEnd) { 70 IntType2 array[kArraySize]; 71 IntType2* ptr = array; 72 for (auto i : IntegerRange(aBegin, aEnd)) { 73 static_assert(std::is_same_v<decltype(i), IntType2>, 74 "type of the loop var " 75 "should be same as that of the second param"); 76 *ptr++ = i; 77 } 78 79 MOZ_RELEASE_ASSERT(ptr - array == static_cast<ptrdiff_t>(aEnd - aBegin), 80 "Should iterates (aEnd - aBegin) times"); 81 for (size_t i = 0; i < static_cast<size_t>(aEnd - aBegin); i++) { 82 MOZ_RELEASE_ASSERT(array[i] == static_cast<IntType2>(aBegin + i), 83 "Should iterate integers in [aBegin, aEnd) in order"); 84 } 85 } 86 87 template <typename IntType1, typename IntType2> 88 static void TestDoubleParamReverseRange(const IntType1 aBegin, 89 const IntType2 aEnd) { 90 IntType2 array[kArraySize]; 91 IntType2* ptr = array; 92 for (auto i : Reversed(IntegerRange(aBegin, aEnd))) { 93 static_assert(std::is_same_v<decltype(i), IntType2>, 94 "type of the loop var " 95 "should be same as that of the second param"); 96 *ptr++ = i; 97 } 98 99 MOZ_RELEASE_ASSERT(ptr - array == static_cast<ptrdiff_t>(aEnd - aBegin), 100 "Should iterates (aEnd - aBegin) times"); 101 for (size_t i = 0; i < static_cast<size_t>(aEnd - aBegin); i++) { 102 MOZ_RELEASE_ASSERT( 103 array[i] == static_cast<IntType2>(aEnd - i - 1), 104 "Should iterate integers in [aBegin, aEnd) in reverse order"); 105 } 106 } 107 108 template <typename IntType1, typename IntType2> 109 static void TestDoubleParamIntegerRange() { 110 const auto kStart = GenerateNumber<IntType1>(); 111 const auto kEnd = static_cast<IntType2>(kStart + GenerateNumber<IntType2>()); 112 TestDoubleParamRange(kStart, static_cast<IntType2>(kStart)); 113 TestDoubleParamReverseRange(kStart, static_cast<IntType2>(kStart)); 114 TestDoubleParamRange(kStart, kEnd); 115 TestDoubleParamReverseRange(kStart, kEnd); 116 } 117 118 int main() { 119 TestSingleParamIntegerRange<int8_t>(); 120 TestSingleParamIntegerRange<int16_t>(); 121 TestSingleParamIntegerRange<int32_t>(); 122 TestSingleParamIntegerRange<int64_t>(); 123 124 TestSingleParamIntegerRange<uint8_t>(); 125 TestSingleParamIntegerRange<uint16_t>(); 126 TestSingleParamIntegerRange<uint32_t>(); 127 TestSingleParamIntegerRange<uint64_t>(); 128 129 TestDoubleParamIntegerRange<int8_t, int8_t>(); 130 TestDoubleParamIntegerRange<int16_t, int16_t>(); 131 TestDoubleParamIntegerRange<int32_t, int32_t>(); 132 TestDoubleParamIntegerRange<int64_t, int64_t>(); 133 134 TestDoubleParamIntegerRange<uint8_t, uint8_t>(); 135 TestDoubleParamIntegerRange<uint16_t, uint16_t>(); 136 TestDoubleParamIntegerRange<uint32_t, uint32_t>(); 137 TestDoubleParamIntegerRange<uint64_t, uint64_t>(); 138 139 TestDoubleParamIntegerRange<int8_t, int16_t>(); 140 TestDoubleParamIntegerRange<int16_t, int32_t>(); 141 TestDoubleParamIntegerRange<int32_t, int64_t>(); 142 TestDoubleParamIntegerRange<int64_t, int8_t>(); 143 144 TestDoubleParamIntegerRange<uint8_t, uint64_t>(); 145 TestDoubleParamIntegerRange<uint16_t, uint8_t>(); 146 TestDoubleParamIntegerRange<uint32_t, uint16_t>(); 147 TestDoubleParamIntegerRange<uint64_t, uint32_t>(); 148 149 return 0; 150 }