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