1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/mfbt/tests/TestEndian.cpp Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,398 @@
1.4 +/* This Source Code Form is subject to the terms of the Mozilla Public
1.5 + * License, v. 2.0. If a copy of the MPL was not distributed with this
1.6 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
1.7 +
1.8 +#include "mozilla/Assertions.h"
1.9 +#include "mozilla/Endian.h"
1.10 +
1.11 +#include <stddef.h>
1.12 +
1.13 +using mozilla::BigEndian;
1.14 +using mozilla::LittleEndian;
1.15 +using mozilla::NativeEndian;
1.16 +
1.17 +template<typename T>
1.18 +void
1.19 +TestSingleSwap(T value, T swappedValue)
1.20 +{
1.21 +#if MOZ_LITTLE_ENDIAN
1.22 + MOZ_RELEASE_ASSERT(NativeEndian::swapToBigEndian(value) == swappedValue);
1.23 + MOZ_RELEASE_ASSERT(NativeEndian::swapFromBigEndian(value) == swappedValue);
1.24 + MOZ_RELEASE_ASSERT(NativeEndian::swapToNetworkOrder(value) == swappedValue);
1.25 + MOZ_RELEASE_ASSERT(NativeEndian::swapFromNetworkOrder(value) == swappedValue);
1.26 +#else
1.27 + MOZ_RELEASE_ASSERT(NativeEndian::swapToLittleEndian(value) == swappedValue);
1.28 + MOZ_RELEASE_ASSERT(NativeEndian::swapFromLittleEndian(value) == swappedValue);
1.29 +#endif
1.30 +}
1.31 +
1.32 +template<typename T>
1.33 +void
1.34 +TestSingleNoSwap(T value, T notSwappedValue)
1.35 +{
1.36 +#if MOZ_LITTLE_ENDIAN
1.37 + MOZ_RELEASE_ASSERT(NativeEndian::swapToLittleEndian(value) == notSwappedValue);
1.38 + MOZ_RELEASE_ASSERT(NativeEndian::swapFromLittleEndian(value) == notSwappedValue);
1.39 +#else
1.40 + MOZ_RELEASE_ASSERT(NativeEndian::swapToBigEndian(value) == notSwappedValue);
1.41 + MOZ_RELEASE_ASSERT(NativeEndian::swapFromBigEndian(value) == notSwappedValue);
1.42 + MOZ_RELEASE_ASSERT(NativeEndian::swapToNetworkOrder(value) == notSwappedValue);
1.43 + MOZ_RELEASE_ASSERT(NativeEndian::swapFromNetworkOrder(value) == notSwappedValue);
1.44 +#endif
1.45 +}
1.46 +
1.47 +// Endian.h functions are declared as protected in an base class and
1.48 +// then re-exported as public in public derived classes. The
1.49 +// standardese around explicit instantiation of templates is not clear
1.50 +// in such cases. Provide these wrappers to make things more explicit.
1.51 +// For your own enlightenment, you may wish to peruse:
1.52 +// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=56152 and subsequently
1.53 +// http://j.mp/XosS6S .
1.54 +#define WRAP_COPYTO(NAME) \
1.55 + template<typename T> \
1.56 + void \
1.57 + NAME(void* dst, const T* src, size_t count) \
1.58 + { \
1.59 + NativeEndian::NAME<T>(dst, src, count); \
1.60 + }
1.61 +
1.62 +WRAP_COPYTO(copyAndSwapToLittleEndian)
1.63 +WRAP_COPYTO(copyAndSwapToBigEndian)
1.64 +WRAP_COPYTO(copyAndSwapToNetworkOrder)
1.65 +
1.66 +#define WRAP_COPYFROM(NAME) \
1.67 + template<typename T> \
1.68 + void \
1.69 + NAME(T* dst, const void* src, size_t count) \
1.70 + { \
1.71 + NativeEndian::NAME<T>(dst, src, count); \
1.72 + }
1.73 +
1.74 +WRAP_COPYFROM(copyAndSwapFromLittleEndian)
1.75 +WRAP_COPYFROM(copyAndSwapFromBigEndian)
1.76 +WRAP_COPYFROM(copyAndSwapFromNetworkOrder)
1.77 +
1.78 +#define WRAP_IN_PLACE(NAME) \
1.79 + template<typename T> \
1.80 + void \
1.81 + NAME(T* p, size_t count) \
1.82 + { \
1.83 + NativeEndian::NAME<T>(p, count); \
1.84 + }
1.85 +WRAP_IN_PLACE(swapToLittleEndianInPlace)
1.86 +WRAP_IN_PLACE(swapFromLittleEndianInPlace)
1.87 +WRAP_IN_PLACE(swapToBigEndianInPlace)
1.88 +WRAP_IN_PLACE(swapFromBigEndianInPlace)
1.89 +WRAP_IN_PLACE(swapToNetworkOrderInPlace)
1.90 +WRAP_IN_PLACE(swapFromNetworkOrderInPlace)
1.91 +
1.92 +enum SwapExpectation {
1.93 + Swap,
1.94 + NoSwap
1.95 +};
1.96 +
1.97 +template<typename T, size_t Count>
1.98 +void
1.99 +TestBulkSwapToSub(enum SwapExpectation expectSwap,
1.100 + const T (&values)[Count],
1.101 + void (*swapperFunc)(void*, const T*, size_t),
1.102 + T (*readerFunc)(const void*))
1.103 +{
1.104 + const size_t arraySize = 2 * Count;
1.105 + const size_t bufferSize = arraySize * sizeof(T);
1.106 + static uint8_t buffer[bufferSize];
1.107 + const uint8_t fillValue = 0xa5;
1.108 + static uint8_t checkBuffer[bufferSize];
1.109 +
1.110 + MOZ_RELEASE_ASSERT(bufferSize > 2 * sizeof(T));
1.111 +
1.112 + memset(checkBuffer, fillValue, bufferSize);
1.113 +
1.114 + for (size_t startPosition = 0; startPosition < sizeof(T); ++startPosition) {
1.115 + for (size_t nValues = 0; nValues < Count; ++nValues) {
1.116 + memset(buffer, fillValue, bufferSize);
1.117 + swapperFunc(buffer + startPosition, values, nValues);
1.118 +
1.119 + MOZ_RELEASE_ASSERT(memcmp(buffer, checkBuffer, startPosition) == 0);
1.120 + size_t valuesEndPosition = startPosition + sizeof(T) * nValues;
1.121 + MOZ_RELEASE_ASSERT(memcmp(buffer + valuesEndPosition,
1.122 + checkBuffer + valuesEndPosition,
1.123 + bufferSize - valuesEndPosition) == 0);
1.124 + if (expectSwap == NoSwap) {
1.125 + MOZ_RELEASE_ASSERT(memcmp(buffer + startPosition, values,
1.126 + nValues * sizeof(T)) == 0);
1.127 + }
1.128 + for (size_t i = 0; i < nValues; ++i) {
1.129 + MOZ_RELEASE_ASSERT(readerFunc(buffer + startPosition + sizeof(T) * i) ==
1.130 + values[i]);
1.131 + }
1.132 + }
1.133 + }
1.134 +}
1.135 +
1.136 +template<typename T, size_t Count>
1.137 +void
1.138 +TestBulkSwapFromSub(enum SwapExpectation expectSwap,
1.139 + const T (&values)[Count],
1.140 + void (*swapperFunc)(T*, const void*, size_t),
1.141 + T (*readerFunc)(const void*))
1.142 +{
1.143 + const size_t arraySize = 2 * Count;
1.144 + const size_t bufferSize = arraySize * sizeof(T);
1.145 + static T buffer[arraySize];
1.146 + const uint8_t fillValue = 0xa5;
1.147 + static T checkBuffer[arraySize];
1.148 +
1.149 + memset(checkBuffer, fillValue, bufferSize);
1.150 +
1.151 + for (size_t startPosition = 0; startPosition < Count; ++startPosition) {
1.152 + for (size_t nValues = 0; nValues < (Count - startPosition); ++nValues) {
1.153 + memset(buffer, fillValue, bufferSize);
1.154 + swapperFunc(buffer + startPosition, values, nValues);
1.155 +
1.156 + MOZ_RELEASE_ASSERT(memcmp(buffer, checkBuffer, startPosition * sizeof(T)) == 0);
1.157 + size_t valuesEndPosition = startPosition + nValues;
1.158 + MOZ_RELEASE_ASSERT(memcmp(buffer + valuesEndPosition,
1.159 + checkBuffer + valuesEndPosition,
1.160 + (arraySize - valuesEndPosition) * sizeof(T)) == 0);
1.161 + if (expectSwap == NoSwap) {
1.162 + MOZ_RELEASE_ASSERT(memcmp(buffer + startPosition, values,
1.163 + nValues * sizeof(T)) == 0);
1.164 + }
1.165 + for (size_t i = 0; i < nValues; ++i)
1.166 + MOZ_RELEASE_ASSERT(readerFunc(buffer + startPosition + i) == values[i]);
1.167 + }
1.168 + }
1.169 +}
1.170 +
1.171 +
1.172 +template<typename T, size_t Count>
1.173 +void
1.174 +TestBulkInPlaceSub(enum SwapExpectation expectSwap,
1.175 + const T (&values)[Count],
1.176 + void (*swapperFunc)(T* p, size_t),
1.177 + T (*readerFunc)(const void*))
1.178 +{
1.179 + const size_t bufferCount = 4 * Count;
1.180 + const size_t bufferSize = bufferCount * sizeof(T);
1.181 + static T buffer[bufferCount];
1.182 + const T fillValue = 0xa5;
1.183 + static T checkBuffer[bufferCount];
1.184 +
1.185 + MOZ_RELEASE_ASSERT(bufferSize > 2 * sizeof(T));
1.186 +
1.187 + memset(checkBuffer, fillValue, bufferSize);
1.188 +
1.189 + for (size_t startPosition = 0; startPosition < Count; ++startPosition) {
1.190 + for (size_t nValues = 0; nValues < Count; ++nValues) {
1.191 + memset(buffer, fillValue, bufferSize);
1.192 + memcpy(buffer + startPosition, values, nValues * sizeof(T));
1.193 + swapperFunc(buffer + startPosition, nValues);
1.194 +
1.195 + MOZ_RELEASE_ASSERT(memcmp(buffer, checkBuffer, startPosition * sizeof(T)) == 0);
1.196 + size_t valuesEndPosition = startPosition + nValues;
1.197 + MOZ_RELEASE_ASSERT(memcmp(buffer + valuesEndPosition,
1.198 + checkBuffer + valuesEndPosition,
1.199 + bufferSize - valuesEndPosition * sizeof(T)) == 0);
1.200 + if (expectSwap == NoSwap) {
1.201 + MOZ_RELEASE_ASSERT(memcmp(buffer + startPosition, values,
1.202 + nValues * sizeof(T)) == 0);
1.203 + }
1.204 + for (size_t i = 0; i < nValues; ++i)
1.205 + MOZ_RELEASE_ASSERT(readerFunc(buffer + startPosition + i) == values[i]);
1.206 + }
1.207 + }
1.208 +}
1.209 +
1.210 +template<typename T>
1.211 +struct Reader
1.212 +{
1.213 +};
1.214 +
1.215 +#define SPECIALIZE_READER(TYPE, READ_FUNC) \
1.216 + template<> \
1.217 + struct Reader<TYPE> \
1.218 + { \
1.219 + static TYPE readLE(const void* p) { return LittleEndian::READ_FUNC(p); } \
1.220 + static TYPE readBE(const void* p) { return BigEndian::READ_FUNC(p); } \
1.221 + };
1.222 +
1.223 +SPECIALIZE_READER(uint16_t, readUint16)
1.224 +SPECIALIZE_READER(uint32_t, readUint32)
1.225 +SPECIALIZE_READER(uint64_t, readUint64)
1.226 +SPECIALIZE_READER(int16_t, readInt16)
1.227 +SPECIALIZE_READER(int32_t, readInt32)
1.228 +SPECIALIZE_READER(int64_t, readInt64)
1.229 +
1.230 +template<typename T, size_t Count>
1.231 +void
1.232 +TestBulkSwap(const T (&bytes)[Count])
1.233 +{
1.234 +#if MOZ_LITTLE_ENDIAN
1.235 + TestBulkSwapToSub(Swap, bytes, copyAndSwapToBigEndian<T>, Reader<T>::readBE);
1.236 + TestBulkSwapFromSub(Swap, bytes, copyAndSwapFromBigEndian<T>, Reader<T>::readBE);
1.237 + TestBulkSwapToSub(Swap, bytes, copyAndSwapToNetworkOrder<T>, Reader<T>::readBE);
1.238 + TestBulkSwapFromSub(Swap, bytes, copyAndSwapFromNetworkOrder<T>, Reader<T>::readBE);
1.239 +#else
1.240 + TestBulkSwapToSub(Swap, bytes, copyAndSwapToLittleEndian<T>, Reader<T>::readLE);
1.241 + TestBulkSwapFromSub(Swap, bytes, copyAndSwapFromLittleEndian<T>, Reader<T>::readLE);
1.242 +#endif
1.243 +}
1.244 +
1.245 +template<typename T, size_t Count>
1.246 +void
1.247 +TestBulkNoSwap(const T (&bytes)[Count])
1.248 +{
1.249 +#if MOZ_LITTLE_ENDIAN
1.250 + TestBulkSwapToSub(NoSwap, bytes, copyAndSwapToLittleEndian<T>, Reader<T>::readLE);
1.251 + TestBulkSwapFromSub(NoSwap, bytes, copyAndSwapFromLittleEndian<T>, Reader<T>::readLE);
1.252 +#else
1.253 + TestBulkSwapToSub(NoSwap, bytes, copyAndSwapToBigEndian<T>, Reader<T>::readBE);
1.254 + TestBulkSwapFromSub(NoSwap, bytes, copyAndSwapFromBigEndian<T>, Reader<T>::readBE);
1.255 + TestBulkSwapToSub(NoSwap, bytes, copyAndSwapToNetworkOrder<T>, Reader<T>::readBE);
1.256 + TestBulkSwapFromSub(NoSwap, bytes, copyAndSwapFromNetworkOrder<T>, Reader<T>::readBE);
1.257 +#endif
1.258 +}
1.259 +
1.260 +template<typename T, size_t Count>
1.261 +void
1.262 +TestBulkInPlaceSwap(const T (&bytes)[Count])
1.263 +{
1.264 +#if MOZ_LITTLE_ENDIAN
1.265 + TestBulkInPlaceSub(Swap, bytes, swapToBigEndianInPlace<T>, Reader<T>::readBE);
1.266 + TestBulkInPlaceSub(Swap, bytes, swapFromBigEndianInPlace<T>, Reader<T>::readBE);
1.267 + TestBulkInPlaceSub(Swap, bytes, swapToNetworkOrderInPlace<T>, Reader<T>::readBE);
1.268 + TestBulkInPlaceSub(Swap, bytes, swapFromNetworkOrderInPlace<T>, Reader<T>::readBE);
1.269 +#else
1.270 + TestBulkInPlaceSub(Swap, bytes, swapToLittleEndianInPlace<T>, Reader<T>::readLE);
1.271 + TestBulkInPlaceSub(Swap, bytes, swapFromLittleEndianInPlace<T>, Reader<T>::readLE);
1.272 +#endif
1.273 +}
1.274 +
1.275 +template<typename T, size_t Count>
1.276 +void
1.277 +TestBulkInPlaceNoSwap(const T (&bytes)[Count])
1.278 +{
1.279 +#if MOZ_LITTLE_ENDIAN
1.280 + TestBulkInPlaceSub(NoSwap, bytes, swapToLittleEndianInPlace<T>, Reader<T>::readLE);
1.281 + TestBulkInPlaceSub(NoSwap, bytes, swapFromLittleEndianInPlace<T>, Reader<T>::readLE);
1.282 +#else
1.283 + TestBulkInPlaceSub(NoSwap, bytes, swapToBigEndianInPlace<T>, Reader<T>::readBE);
1.284 + TestBulkInPlaceSub(NoSwap, bytes, swapFromBigEndianInPlace<T>, Reader<T>::readBE);
1.285 + TestBulkInPlaceSub(NoSwap, bytes, swapToNetworkOrderInPlace<T>, Reader<T>::readBE);
1.286 + TestBulkInPlaceSub(NoSwap, bytes, swapFromNetworkOrderInPlace<T>, Reader<T>::readBE);
1.287 +#endif
1.288 +}
1.289 +
1.290 +int
1.291 +main()
1.292 +{
1.293 + static const uint8_t unsigned_bytes[16] = { 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8,
1.294 + 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8 };
1.295 + static const int8_t signed_bytes[16] = { -0x0f, -0x0e, -0x0d, -0x0c, -0x0b, -0x0a, -0x09, -0x08,
1.296 + -0x0f, -0x0e, -0x0d, -0x0c, -0x0b, -0x0a, -0x09, -0x08 };
1.297 + static const uint16_t uint16_values[8] = { 0x102, 0x304, 0x506, 0x708, 0x102, 0x304, 0x506, 0x708 };
1.298 + static const int16_t int16_values[8] = { int16_t(0xf1f2), int16_t(0xf3f4), int16_t(0xf5f6), int16_t(0xf7f8),
1.299 + int16_t(0xf1f2), int16_t(0xf3f4), int16_t(0xf5f6), int16_t(0xf7f8) };
1.300 + static const uint32_t uint32_values[4] = { 0x1020304, 0x5060708, 0x1020304, 0x5060708 };
1.301 + static const int32_t int32_values[4] = { int32_t(0xf1f2f3f4), int32_t(0xf5f6f7f8),
1.302 + int32_t(0xf1f2f3f4), int32_t(0xf5f6f7f8) };
1.303 + static const uint64_t uint64_values[2] = { 0x102030405060708, 0x102030405060708 };
1.304 + static const int64_t int64_values[2] = { int64_t(0xf1f2f3f4f5f6f7f8),
1.305 + int64_t(0xf1f2f3f4f5f6f7f8) };
1.306 + uint8_t buffer[8];
1.307 +
1.308 + MOZ_RELEASE_ASSERT(LittleEndian::readUint16(&unsigned_bytes[0]) == 0x201);
1.309 + MOZ_RELEASE_ASSERT(BigEndian::readUint16(&unsigned_bytes[0]) == 0x102);
1.310 +
1.311 + MOZ_RELEASE_ASSERT(LittleEndian::readUint32(&unsigned_bytes[0]) == 0x4030201U);
1.312 + MOZ_RELEASE_ASSERT(BigEndian::readUint32(&unsigned_bytes[0]) == 0x1020304U);
1.313 +
1.314 + MOZ_RELEASE_ASSERT(LittleEndian::readUint64(&unsigned_bytes[0]) == 0x807060504030201ULL);
1.315 + MOZ_RELEASE_ASSERT(BigEndian::readUint64(&unsigned_bytes[0]) == 0x102030405060708ULL);
1.316 +
1.317 + LittleEndian::writeUint16(&buffer[0], 0x201);
1.318 + MOZ_RELEASE_ASSERT(memcmp(&unsigned_bytes[0], &buffer[0], sizeof(uint16_t)) == 0);
1.319 + BigEndian::writeUint16(&buffer[0], 0x102);
1.320 + MOZ_RELEASE_ASSERT(memcmp(&unsigned_bytes[0], &buffer[0], sizeof(uint16_t)) == 0);
1.321 +
1.322 + LittleEndian::writeUint32(&buffer[0], 0x4030201U);
1.323 + MOZ_RELEASE_ASSERT(memcmp(&unsigned_bytes[0], &buffer[0], sizeof(uint32_t)) == 0);
1.324 + BigEndian::writeUint32(&buffer[0], 0x1020304U);
1.325 + MOZ_RELEASE_ASSERT(memcmp(&unsigned_bytes[0], &buffer[0], sizeof(uint32_t)) == 0);
1.326 +
1.327 + LittleEndian::writeUint64(&buffer[0], 0x807060504030201ULL);
1.328 + MOZ_RELEASE_ASSERT(memcmp(&unsigned_bytes[0], &buffer[0], sizeof(uint64_t)) == 0);
1.329 + BigEndian::writeUint64(&buffer[0], 0x102030405060708ULL);
1.330 + MOZ_RELEASE_ASSERT(memcmp(&unsigned_bytes[0], &buffer[0], sizeof(uint64_t)) == 0);
1.331 +
1.332 + MOZ_RELEASE_ASSERT(LittleEndian::readInt16(&signed_bytes[0]) == int16_t(0xf2f1));
1.333 + MOZ_RELEASE_ASSERT(BigEndian::readInt16(&signed_bytes[0]) == int16_t(0xf1f2));
1.334 +
1.335 + MOZ_RELEASE_ASSERT(LittleEndian::readInt32(&signed_bytes[0]) == int32_t(0xf4f3f2f1));
1.336 + MOZ_RELEASE_ASSERT(BigEndian::readInt32(&signed_bytes[0]) == int32_t(0xf1f2f3f4));
1.337 +
1.338 + MOZ_RELEASE_ASSERT(LittleEndian::readInt64(&signed_bytes[0]) == int64_t(0xf8f7f6f5f4f3f2f1LL));
1.339 + MOZ_RELEASE_ASSERT(BigEndian::readInt64(&signed_bytes[0]) == int64_t(0xf1f2f3f4f5f6f7f8LL));
1.340 +
1.341 + LittleEndian::writeInt16(&buffer[0], 0xf2f1);
1.342 + MOZ_RELEASE_ASSERT(memcmp(&signed_bytes[0], &buffer[0], sizeof(int16_t)) == 0);
1.343 + BigEndian::writeInt16(&buffer[0], 0xf1f2);
1.344 + MOZ_RELEASE_ASSERT(memcmp(&signed_bytes[0], &buffer[0], sizeof(int16_t)) == 0);
1.345 +
1.346 + LittleEndian::writeInt32(&buffer[0], 0xf4f3f2f1);
1.347 + MOZ_RELEASE_ASSERT(memcmp(&signed_bytes[0], &buffer[0], sizeof(int32_t)) == 0);
1.348 + BigEndian::writeInt32(&buffer[0], 0xf1f2f3f4);
1.349 + MOZ_RELEASE_ASSERT(memcmp(&signed_bytes[0], &buffer[0], sizeof(int32_t)) == 0);
1.350 +
1.351 + LittleEndian::writeInt64(&buffer[0], 0xf8f7f6f5f4f3f2f1LL);
1.352 + MOZ_RELEASE_ASSERT(memcmp(&signed_bytes[0], &buffer[0], sizeof(int64_t)) == 0);
1.353 + BigEndian::writeInt64(&buffer[0], 0xf1f2f3f4f5f6f7f8LL);
1.354 + MOZ_RELEASE_ASSERT(memcmp(&signed_bytes[0], &buffer[0], sizeof(int64_t)) == 0);
1.355 +
1.356 + TestSingleSwap(uint16_t(0xf2f1), uint16_t(0xf1f2));
1.357 + TestSingleSwap(uint32_t(0xf4f3f2f1), uint32_t(0xf1f2f3f4));
1.358 + TestSingleSwap(uint64_t(0xf8f7f6f5f4f3f2f1), uint64_t(0xf1f2f3f4f5f6f7f8));
1.359 +
1.360 + TestSingleSwap(int16_t(0xf2f1), int16_t(0xf1f2));
1.361 + TestSingleSwap(int32_t(0xf4f3f2f1), int32_t(0xf1f2f3f4));
1.362 + TestSingleSwap(int64_t(0xf8f7f6f5f4f3f2f1), int64_t(0xf1f2f3f4f5f6f7f8));
1.363 +
1.364 + TestSingleNoSwap(uint16_t(0xf2f1), uint16_t(0xf2f1));
1.365 + TestSingleNoSwap(uint32_t(0xf4f3f2f1), uint32_t(0xf4f3f2f1));
1.366 + TestSingleNoSwap(uint64_t(0xf8f7f6f5f4f3f2f1), uint64_t(0xf8f7f6f5f4f3f2f1));
1.367 +
1.368 + TestSingleNoSwap(int16_t(0xf2f1), int16_t(0xf2f1));
1.369 + TestSingleNoSwap(int32_t(0xf4f3f2f1), int32_t(0xf4f3f2f1));
1.370 + TestSingleNoSwap(int64_t(0xf8f7f6f5f4f3f2f1), int64_t(0xf8f7f6f5f4f3f2f1));
1.371 +
1.372 + TestBulkSwap(uint16_values);
1.373 + TestBulkSwap(int16_values);
1.374 + TestBulkSwap(uint32_values);
1.375 + TestBulkSwap(int32_values);
1.376 + TestBulkSwap(uint64_values);
1.377 + TestBulkSwap(int64_values);
1.378 +
1.379 + TestBulkNoSwap(uint16_values);
1.380 + TestBulkNoSwap(int16_values);
1.381 + TestBulkNoSwap(uint32_values);
1.382 + TestBulkNoSwap(int32_values);
1.383 + TestBulkNoSwap(uint64_values);
1.384 + TestBulkNoSwap(int64_values);
1.385 +
1.386 + TestBulkInPlaceSwap(uint16_values);
1.387 + TestBulkInPlaceSwap(int16_values);
1.388 + TestBulkInPlaceSwap(uint32_values);
1.389 + TestBulkInPlaceSwap(int32_values);
1.390 + TestBulkInPlaceSwap(uint64_values);
1.391 + TestBulkInPlaceSwap(int64_values);
1.392 +
1.393 + TestBulkInPlaceNoSwap(uint16_values);
1.394 + TestBulkInPlaceNoSwap(int16_values);
1.395 + TestBulkInPlaceNoSwap(uint32_values);
1.396 + TestBulkInPlaceNoSwap(int32_values);
1.397 + TestBulkInPlaceNoSwap(uint64_values);
1.398 + TestBulkInPlaceNoSwap(int64_values);
1.399 +
1.400 + return 0;
1.401 +}
