coffee/etl
1
0
Fork 0
mirror of https://github.com/ETLCPP/etl.git synced 2026-04-30 19:09:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix tests on big endian (#1142)

Browse Source 
* Fix bitset_new test: bitset is implemented as little endian container

* Fix test_bsd_checksum.cpp: endian test was only implemented for little endian

* Fix endianness test

* Fix endian in crc tests

* Fix test_fnv_1

* Fix test_hash

* Fix test_jenkins

* Fix test_memory

* Fix pearson test

* Fix test_xor_rotate_checksum

* Fix murmur test
This commit is contained in:
rolandreichweinmusic 2025-07-07 09:55:59 +02:00 committed by GitHub
parent 72e71a8cb6
commit 28da1fa3ef
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
60 changed files with 1528 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
test/murmurhash3.cpp
View File

@ -14,6 +14,8 @@
#endif
#include "murmurhash3.h"
#include "etl/bit.h"
#include "etl/endianness.h"
//-----------------------------------------------------------------------------
// Platform-specific functions and macros
@ -60,13 +62,27 @@ inline uint64_t rotl64(uint64_t x, int8_t r)
FORCE_INLINE uint32_t getblock32(const uint32_t * p, int i)
{
return p[i];
if (etl::endianness::value() == etl::endian::little)
{
return p[i];
}
else
{
return etl::byteswap(p[i]);
}
}
#if ETL_USING_64BIT_TYPES
FORCE_INLINE uint64_t getblock64(const uint64_t * p, int i)
{
return p[i];
if (etl::endianness::value() == etl::endian::little)
{
return p[i];
}
else
{
return etl::byteswap(p[i]);
}
}
#endif

37
test/test_bitset_new_default_element_type.cpp
View File

@ -37,7 +37,6 @@ SOFTWARE.
#include "etl/wstring.h"
#include "etl/u16string.h"
#include "etl/u32string.h"
#include "etl/endianness.h"
namespace
{
@ -2105,20 +2104,10 @@ namespace
span_t s = b.span();
if (etl::endianness::value() == etl::endian::little)
{
CHECK_EQUAL(0x78UL, s[0]);
CHECK_EQUAL(0x56UL, s[1]);
CHECK_EQUAL(0x34UL, s[2]);
CHECK_EQUAL(0x12UL, s[3]);
}
else
{
CHECK_EQUAL(0x78UL, s[3]);
CHECK_EQUAL(0x56UL, s[2]);
CHECK_EQUAL(0x34UL, s[1]);
CHECK_EQUAL(0x12UL, s[0]);
}
CHECK_EQUAL(0x78UL, s[0]);
CHECK_EQUAL(0x56UL, s[1]);
CHECK_EQUAL(0x34UL, s[2]);
CHECK_EQUAL(0x12UL, s[3]);
s[2] = 0x9AU;
uint32_t value = b.value<uint32_t>();
@ -2134,20 +2123,10 @@ namespace
span_t s = b.span();
if (etl::endianness::value() == etl::endian::little)
{
CHECK_EQUAL(0x78UL, s[0]);
CHECK_EQUAL(0x56UL, s[1]);
CHECK_EQUAL(0x34UL, s[2]);
CHECK_EQUAL(0x12UL, s[3]);
}
else
{
CHECK_EQUAL(0x78UL, s[3]);
CHECK_EQUAL(0x56UL, s[2]);
CHECK_EQUAL(0x34UL, s[1]);
CHECK_EQUAL(0x12UL, s[0]);
}
CHECK_EQUAL(0x78UL, s[0]);
CHECK_EQUAL(0x56UL, s[1]);
CHECK_EQUAL(0x34UL, s[2]);
CHECK_EQUAL(0x12UL, s[3]);
}
//*************************************************************************

36
test/test_bitset_new_ext_default_element_type.cpp
View File

@ -1803,20 +1803,10 @@ namespace
span_t s = b.span();
if (etl::endianness::value() == etl::endian::little)
{
CHECK_EQUAL(0x78UL, s[0]);
CHECK_EQUAL(0x56UL, s[1]);
CHECK_EQUAL(0x34UL, s[2]);
CHECK_EQUAL(0x12UL, s[3]);
}
else
{
CHECK_EQUAL(0x78UL, s[3]);
CHECK_EQUAL(0x56UL, s[2]);
CHECK_EQUAL(0x34UL, s[1]);
CHECK_EQUAL(0x12UL, s[0]);
}
CHECK_EQUAL(0x78UL, s[0]);
CHECK_EQUAL(0x56UL, s[1]);
CHECK_EQUAL(0x34UL, s[2]);
CHECK_EQUAL(0x12UL, s[3]);
s[2] = 0x9AU;
uint32_t value = b.value<uint32_t>();
@ -1833,20 +1823,10 @@ namespace
bs32 b(0x12345678UL, buffer);
span_t s = b.span();
if (etl::endianness::value() == etl::endian::little)
{
CHECK_EQUAL(0x78UL, s[0]);
CHECK_EQUAL(0x56UL, s[1]);
CHECK_EQUAL(0x34UL, s[2]);
CHECK_EQUAL(0x12UL, s[3]);
}
else
{
CHECK_EQUAL(0x78UL, s[3]);
CHECK_EQUAL(0x56UL, s[2]);
CHECK_EQUAL(0x34UL, s[1]);
CHECK_EQUAL(0x12UL, s[0]);
}
CHECK_EQUAL(0x78UL, s[0]);
CHECK_EQUAL(0x56UL, s[1]);
CHECK_EQUAL(0x34UL, s[2]);
CHECK_EQUAL(0x12UL, s[3]);
}
//*************************************************************************

11
test/test_bsd_checksum.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/checksum.h"
#include "etl/endianness.h"
namespace
{
@ -155,7 +156,15 @@ namespace
TEST(test_checksum_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint64_t hash1 = etl::bsd_checksum<uint8_t>(data1.begin(), data1.end());

31
test/test_crc16.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -104,7 +105,15 @@ namespace
TEST(test_crc16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16(data1.begin(), data1.end());
@ -187,7 +196,15 @@ namespace
TEST(test_crc16_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_t16(data1.begin(), data1.end());
@ -270,7 +287,15 @@ namespace
TEST(test_crc16_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_t4(data1.begin(), data1.end());

31
test/test_crc16_a.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_a.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_a_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_a(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_a_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_a_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_a_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_a_t4(data1.begin(), data1.end());

31
test/test_crc16_arc.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_arc.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_arc_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_arc(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_arc_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_arc_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_arc_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_arc_t4(data1.begin(), data1.end());

31
test/test_crc16_aug_ccitt.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_aug_ccitt.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_aug_ccitt_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_aug_ccitt(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_aug_ccitt_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_aug_ccitt_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_aug_ccitt_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_aug_ccitt_t4(data1.begin(), data1.end());

31
test/test_crc16_buypass.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_buypass.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_buypass_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_buypass(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_buypass_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_buypass_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_buypass_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_buypass_t4(data1.begin(), data1.end());

31
test/test_crc16_ccitt.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_ccitt.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_ccitt_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_ccitt(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_ccitt_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_ccitt_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_ccitt_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_ccitt_t4(data1.begin(), data1.end());

31
test/test_crc16_cdma2000.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_cdma2000.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_cdma2000_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_cdma2000(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_cdma2000_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_cdma2000_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_cdma2000_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_cdma2000_t4(data1.begin(), data1.end());

31
test/test_crc16_dds110.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_dds110.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_dds110_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dds110(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_dds110_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dds110_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_dds110_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dds110_t4(data1.begin(), data1.end());

31
test/test_crc16_dectr.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_dectr.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_dect_r_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dectr(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_dect_r_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dect_r_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_dect_r_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dect_r_t4(data1.begin(), data1.end());

31
test/test_crc16_dectx.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_dectx.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_dect_x_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dectx(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_dect_x_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dect_x_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_dect_x_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dect_x_t4(data1.begin(), data1.end());

31
test/test_crc16_dnp.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_dnp.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_dnp_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dnp(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_dnp_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dnp_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_dnp_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_dnp_t4(data1.begin(), data1.end());

31
test/test_crc16_en13757.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_en13757.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_en13757_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_en13757(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_en13757_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_en13757_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_en13757_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_en13757_t4(data1.begin(), data1.end());

31
test/test_crc16_genibus.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_genibus.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_genibus_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_genibus(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_genibus_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_genibus_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_genibus_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_genibus_t4(data1.begin(), data1.end());

31
test/test_crc16_kermit.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_kermit.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_kermit_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_kermit(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_kermit_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_kermit_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_kermit_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_kermit_t4(data1.begin(), data1.end());

31
test/test_crc16_m17.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_m17.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_m17_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_m17(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_m17_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_m17_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_m17_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_m17_t4(data1.begin(), data1.end());

31
test/test_crc16_maxim.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_maxim.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_maxim_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_maxim(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_maxim_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_maxim_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_maxim_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_maxim_t4(data1.begin(), data1.end());

31
test/test_crc16_mcrf4xx.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_mcrf4xx.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_mcrf4xx_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_mcrf4xx(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_mcrf4xx_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_mcrf4xx_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_mcrf4xx_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_mcrf4xx_t4(data1.begin(), data1.end());

31
test/test_crc16_modbus.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_modbus.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_modbus_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_modbus(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_modbus_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_modbus_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_modbus_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_modbus_t4(data1.begin(), data1.end());

31
test/test_crc16_profibus.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_profibus.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_profibus_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_profibus(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_profibus_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_profibus_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_profibus_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_profibus_t4(data1.begin(), data1.end());

31
test/test_crc16_riello.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_riello.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_riello_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_riello(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_riello_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_riello_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_riello_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_riello_t4(data1.begin(), data1.end());

31
test/test_crc16_t10dif.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_t10dif.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_t10dif_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_t10dif(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_t10dif_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_t10dif_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_t10dif_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_t10dif_t4(data1.begin(), data1.end());

31
test/test_crc16_teledisk.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_teledisk.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_teledisk_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_teledisk(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_teledisk_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_teledisk_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_teledisk_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_teledisk_t4(data1.begin(), data1.end());

31
test/test_crc16_tms37157.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_tms37157.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_tms37157_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_tms37157(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_tms37157_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_tms37157_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_tms37157_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_tms37157_t4(data1.begin(), data1.end());

31
test/test_crc16_usb.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_usb.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_usb_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_usb(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_usb_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_usb_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_usb_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_usb_t4(data1.begin(), data1.end());

31
test/test_crc16_x25.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_x25.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_x25_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_x25(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_x25_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_x25_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_x25_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_x25_t4(data1.begin(), data1.end());

31
test/test_crc16_xmodem.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc16_xmodem.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc16_xmodem_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_xmodem(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc16_xmodem_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_xmodem_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc16_xmodem_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint16_t crc1 = etl::crc16_xmodem_t4(data1.begin(), data1.end());

31
test/test_crc32.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc32.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -104,7 +105,15 @@ namespace
TEST(test_crc32_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32(data1.begin(), data1.end());
@ -187,7 +196,15 @@ namespace
TEST(test_crc32_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_t16(data1.begin(), data1.end());
@ -270,7 +287,15 @@ namespace
TEST(test_crc32_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_t4(data1.begin(), data1.end());

31
test/test_crc32_bzip2.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc32_bzip2.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc32_bzip2_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_bzip2(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc32_bzip2_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_bzip2_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc32_bzip2_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_bzip2_t4(data1.begin(), data1.end());

31
test/test_crc32_c.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc32_c.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc32_c_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_c(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc32_c_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_c_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc32_c_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_c_t4(data1.begin(), data1.end());

31
test/test_crc32_d.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc32_d.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc32_d_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_d(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc32_d_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_d_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc32_d_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_d_t4(data1.begin(), data1.end());

31
test/test_crc32_jamcrc.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc32_jamcrc.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc32_jamcrc_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_jamcrc(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc32_jamcrc_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_jamcrc_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc32_jamcrc_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_jamcrc_t4(data1.begin(), data1.end());

31
test/test_crc32_mpeg2.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc32_mpeg2.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc32_mpeg2_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_mpeg2(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc32_mpeg2_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_mpeg2_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc32_mpeg2_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_mpeg2_t4(data1.begin(), data1.end());

31
test/test_crc32_posix.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc32_posix.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc32_posix_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_posix(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc32_posix_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_posix_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc32_posix_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_posix_t4(data1.begin(), data1.end());

31
test/test_crc32_q.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc32_q.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc32_q_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_q(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc32_q_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_q_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc32_q_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_q_t4(data1.begin(), data1.end());

31
test/test_crc32_xfer.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc32_xfer.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc32_xfer_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_xfer(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc32_xfer_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_xfer_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc32_xfer_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t crc1 = etl::crc32_xfer_t4(data1.begin(), data1.end());

31
test/test_crc64_ecma.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc64_ecma.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc64_ecma_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint64_t crc1 = etl::crc64_ecma(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc64_ecma_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint64_t crc1 = etl::crc64_ecma_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc64_ecma_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint64_t crc1 = etl::crc64_ecma_t4(data1.begin(), data1.end());

31
test/test_crc8_ccitt.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_ccitt.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_ccitt_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_ccitt_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_ccitt_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_ccitt_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_ccitt_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_ccitt(data1.begin(), data1.end());

31
test/test_crc8_cdma2000.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_cdma2000.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_cdma2000_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_cdma2000_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_cdma2000_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_cdma2000_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_cdma2000_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_cdma2000(data1.begin(), data1.end());

31
test/test_crc8_darc.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_darc.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_darc_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_darc_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_darc_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_darc_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_darc_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_darc(data1.begin(), data1.end());

31
test/test_crc8_dvbs2.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_dvbs2.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_dvbs2_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_dvbs2_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_dvbs2_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_dvbs2_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_dvbs2_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_dvbs2(data1.begin(), data1.end());

31
test/test_crc8_ebu.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_ebu.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_ebu_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_ebu_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_ebu_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_ebu_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_ebu_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_ebu(data1.begin(), data1.end());

31
test/test_crc8_icode.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_icode.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_icode_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_icode_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_icode_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_icode_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_icode_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_icode(data1.begin(), data1.end());

31
test/test_crc8_itu.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_itu.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_itu_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_itu_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_itu_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_itu_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_itu_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_itu(data1.begin(), data1.end());

31
test/test_crc8_j1850.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_j1850.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from http://www.sunshine2k.de/coding/javascript/crc/crc_js.html
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_j1850_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_j1850_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_j1850_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_j1850_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_j1850_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_j1850(data1.begin(), data1.end());

31
test/test_crc8_j1850_zero.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_j1850_zero.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from http://www.sunshine2k.de/coding/javascript/crc/crc_js.html
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_j1850_zero_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_j1850_zero_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_j1850_zero_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_j1850_zero_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_j1850_zero_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_j1850_zero(data1.begin(), data1.end());

31
test/test_crc8_maxim.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_maxim.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_maxim_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_maxim_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_maxim_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_maxim_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_maxim_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_maxim(data1.begin(), data1.end());

31
test/test_crc8_rohc.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_rohc.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_rohc_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_rohc_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_rohc_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_rohc_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_rohc_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_rohc(data1.begin(), data1.end());

31
test/test_crc8_wcdma.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/crc8_wcdma.h"
#include "etl/endianness.h"
//*****************************************************************************
// The results for these tests were created from https://crccalc.com/
@ -115,7 +116,15 @@ namespace
TEST(test_crc8_wcdma_4_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_wcdma_t4(data1.begin(), data1.end());
@ -198,7 +207,15 @@ namespace
TEST(test_crc8_wcdma_16_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_wcdma_t16(data1.begin(), data1.end());
@ -281,7 +298,15 @@ namespace
TEST(test_crc8_wcdma_256_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint8_t crc1 = etl::crc8_wcdma(data1.begin(), data1.end());

26
test/test_endian.cpp
View File

@ -38,12 +38,28 @@ namespace
//*************************************************************************
TEST(test_endianness)
{
// Intel platform is little endian.
CHECK(etl::endianness()() == etl::endian::little);
CHECK(etl::endianness()() != etl::endian::big);
#if defined(ETL_ENDIAN_NATIVE) && defined(ETL_ENDIAN_BIG)
if (ETL_ENDIAN_NATIVE == ETL_ENDIAN_BIG)
{
// Big endian platforms
CHECK(etl::endianness()() != etl::endian::little);
CHECK(etl::endianness()() == etl::endian::big);
CHECK(etl::endianness::value() == etl::endian::little);
CHECK(etl::endianness::value() != etl::endian::big);
CHECK(etl::endianness::value() != etl::endian::little);
CHECK(etl::endianness::value() == etl::endian::big);
}
else
{
// Little endian platforms
CHECK(etl::endianness()() == etl::endian::little);
CHECK(etl::endianness()() != etl::endian::big);
CHECK(etl::endianness::value() == etl::endian::little);
CHECK(etl::endianness::value() != etl::endian::big);
}
#else
#error Endianness unknown: Test not possible
#endif
}
};
}

41
test/test_fnv_1.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/fnv_1.h"
#include "etl/endianness.h"
namespace
{
@ -98,7 +99,15 @@ namespace
TEST(test_fnv_1_32_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t hash1 = etl::fnv_1_32(data1.begin(), data1.end());
@ -168,7 +177,15 @@ namespace
TEST(test_fnv_1a_32_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t hash1 = etl::fnv_1a_32(data1.begin(), data1.end());
@ -238,7 +255,15 @@ namespace
TEST(test_fnv_1_64_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint64_t hash1 = etl::fnv_1_64(data1.begin(), data1.end());
@ -308,7 +333,15 @@ namespace
TEST(test_fnv_1a_64_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint64_t hash1 = etl::fnv_1a_64(data1.begin(), data1.end());

10
test/test_hash.cpp
View File

@ -35,6 +35,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/hash.h"
#include "etl/endianness.h"
// for testing user-defined hash specializations
namespace { class CustomType{}; }
@ -177,7 +178,14 @@ namespace
if (ETL_PLATFORM_64BIT)
{
CHECK_EQUAL(9821047038287739023U, hash);
if (etl::endianness::value() == etl::endian::little)
{
CHECK_EQUAL(9821047038287739023U, hash);
}
else
{
CHECK_EQUAL(15239628249615675935U, hash);
}
}
}

11
test/test_jenkins.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/jenkins.h"
#include "etl/endianness.h"
template <typename TIterator>
uint32_t jenkins(TIterator begin, TIterator end)
@ -123,7 +124,15 @@ namespace
TEST(test_jenkins_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint32_t hash1 = etl::jenkins(data1.begin(), data1.end());

37
test/test_memory.cpp
View File

@ -31,6 +31,7 @@ SOFTWARE.
#include "etl/memory.h"
#include "etl/list.h"
#include "etl/debug_count.h"
#include "etl/endianness.h"
#include "data.h"
@ -1370,7 +1371,14 @@ namespace
char* p2 = etl::mem_char(data, data + 8, (char)0x99);
CHECK_EQUAL(uint32_t(0x29), uint32_t(*p1));
CHECK((reinterpret_cast<char*>(data) + 18) == p1);
if (etl::endianness::value() == etl::endian::little)
{
CHECK((reinterpret_cast<char*>(data) + 18) == p1);
}
else
{
CHECK((reinterpret_cast<char*>(data) + 17) == p1);
}
CHECK((reinterpret_cast<char*>(data) + 32) == p2);
}
@ -1383,7 +1391,14 @@ namespace
const char* p2 = etl::mem_char(data, data + 8, (char)0x99);
CHECK_EQUAL(uint32_t(0x29), uint32_t(*p1));
CHECK((reinterpret_cast<const char*>(data) + 18) == p1);
if (etl::endianness::value() == etl::endian::little)
{
CHECK((reinterpret_cast<const char*>(data) + 18) == p1);
}
else
{
CHECK((reinterpret_cast<const char*>(data) + 17) == p1);
}
CHECK((reinterpret_cast<const char*>(data) + 32) == p2);
}
@ -1396,7 +1411,14 @@ namespace
char* p2 = etl::mem_char(data, 8, (char)0x99);
CHECK_EQUAL(uint32_t(0x29), uint32_t(*p1));
CHECK((reinterpret_cast<char*>(data) + 18) == p1);
if (etl::endianness::value() == etl::endian::little)
{
CHECK((reinterpret_cast<char*>(data) + 18) == p1);
}
else
{
CHECK((reinterpret_cast<char*>(data) + 17) == p1);
}
CHECK((reinterpret_cast<char*>(data) + 32) == p2);
}
@ -1409,7 +1431,14 @@ namespace
const char* p2 = etl::mem_char(data, 8, (char)0x99);
CHECK_EQUAL(uint32_t(0x29), uint32_t(*p1));
CHECK((reinterpret_cast<const char*>(data) + 18) == p1);
if (etl::endianness::value() == etl::endian::little)
{
CHECK((reinterpret_cast<const char*>(data) + 18) == p1);
}
else
{
CHECK((reinterpret_cast<const char*>(data) + 17) == p1);
}
CHECK((reinterpret_cast<const char*>(data) + 32) == p2);
}

11
test/test_murmur3.cpp
View File

@ -39,6 +39,7 @@ SOFTWARE.
#include "etl/murmur3.h"
#include "etl/alignment.h"
#include "etl/endianness.h"
namespace
{
@ -110,7 +111,15 @@ namespace
TEST(test_murmur3_32_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
uint32_t hash1 = etl::murmur3<uint32_t>(data1.begin(), data1.end());
uint32_t hash2 = etl::murmur3<uint32_t>((uint8_t*)&data2[0], (uint8_t*)&data2[0] + (data2.size() * sizeof(uint32_t)));

11
test/test_pearson.cpp
View File

@ -35,6 +35,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/pearson.h"
#include "etl/endianness.h"
const size_t HASH_SIZE = 8;
typedef etl::pearson<HASH_SIZE>::value_type hash_t;
@ -155,7 +156,15 @@ namespace
TEST(test_pearson_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
hash_t hash1 = etl::pearson<HASH_SIZE>(data1.begin(), data1.end());

11
test/test_xor_rotate_checksum.cpp
View File

@ -34,6 +34,7 @@ SOFTWARE.
#include <stdint.h>
#include "etl/checksum.h"
#include "etl/endianness.h"
namespace
{
@ -135,7 +136,15 @@ namespace
TEST(test_checksum_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01U, 0x02U, 0x03U, 0x04U, 0x05U, 0x06U, 0x07U, 0x08U };
std::vector<uint32_t> data2 = { 0x04030201UL, 0x08070605UL };
std::vector<uint32_t> data2;
if (etl::endianness::value() == etl::endian::little)
{
data2 = { 0x04030201UL, 0x08070605UL };
}
else
{
data2 = { 0x01020304UL, 0x05060708UL };
}
std::vector<uint8_t> data3 = { 0x08U, 0x07U, 0x06U, 0x05U, 0x04U, 0x03U, 0x02U, 0x01U };
uint64_t hash1 = etl::xor_rotate_checksum<uint8_t>(data1.begin(), data1.end());