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

New hash & checksum algorithms

Browse Source
This commit is contained in:
John Wellbelove 2015-08-19 21:00:53 +01:00
parent 66bb92c328
commit 40e6268bf6
10 changed files with 293560 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

150
bsd_checksum.h Normal file
View File

@ -0,0 +1,150 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
Copyright(c) 2014 jwellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef __ETL_BSDCHECKSUM__
#define __ETL_BSDCHECKSUM__
#include <stdint.h>
#include "static_assert.h"
#include "type_traits.h"
#include "endian.h"
#include "binary.h"
#include "ihash.h"
///\defgroup bsdchecksum BSD Checksum calculation
///\ingroup maths
namespace etl
{
//***************************************************************************
/// Calculates the checksum.
///\tparam TSum The type used for the sum.
///\tparam ENDIANNESS The endianness of the calculation for input types larger than uint8_t. Default = endian::little.
///\ingroup checksum
//***************************************************************************
template <typename TSum, const int ENDIANNESS = endian::little>
class bsd_checksum : public etl::ihash
{
public:
STATIC_ASSERT(is_unsigned<TSum>::value, "Signed TSum template parameter not supported");
typedef TSum value_type;
//*************************************************************************
/// Default constructor.
//*************************************************************************
bsd_checksum()
: ihash(etl::endian(ENDIANNESS))
{
reset();
}
//*************************************************************************
/// Constructor from range.
/// \param begin Start of the range.
/// \param end End of the range.
//*************************************************************************
template<typename TIterator>
bsd_checksum(TIterator begin, const TIterator end)
: ihash(etl::endian(ENDIANNESS))
{
reset();
add(begin, end);
}
//*************************************************************************
/// Resets the CRC to the initial state.
//*************************************************************************
void reset()
{
sum = 0;
}
//*************************************************************************
/// Adds a range.
/// \param begin
/// \param end
//*************************************************************************
template<typename TIterator>
void add(TIterator begin, const TIterator end)
{
ihash::add(begin, end);
}
//*************************************************************************
/// Adds a value.
/// \param value The value to add to the checksum.
//*************************************************************************
template<typename TValue>
void add(TValue value)
{
ihash::add(value);
}
//*************************************************************************
/// \param value The uint8_t to add to the checksum.
//*************************************************************************
void add(uint8_t value)
{
sum = rotate_left(sum) + value;
}
//*************************************************************************
/// Gets the checksum value.
//*************************************************************************
value_type value()
{
return sum;
}
//*************************************************************************
/// Conversion operator to value_type.
//*************************************************************************
operator value_type ()
{
return sum;
}
//*************************************************************************
/// Gets the generic digest value.
//*************************************************************************
generic_digest digest()
{
return ihash::get_digest(sum);
}
private:
value_type sum;
};
}
#endif

234
murmur3.h Normal file
View File

@ -0,0 +1,234 @@
///\file
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
Copyright(c) 2014 jwellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#ifndef __ETL_MURMUR3__
#define __ETL_MURMUR3__
#include <stdint.h>
#include "endian.h"
#include "ihash.h"
#include "binary.h"
#ifndef ETL_THROW_EXCEPTIONS
#include "error_handler.h"
#endif
#if defined(COMPILER_KEIL)
#pragma diag_suppress 1300
#endif
///\defgroup murmur3 Murmur3 hash calculations
///\ingroup maths
namespace etl
{
//***************************************************************************
/// Calculates the murmur3_32 hash.
/// See https://en.wikipedia.org/wiki/MurmurHash for more details.
///\tparam ENDIANNESS The endianness of the calculation for input types larger than uint8_t. Default = endian::little.
///\ingroup murmur3_32
//***************************************************************************
template <const int ENDIANNESS = endian::little>
class murmur3_32 : public etl::ihash
{
public:
typedef uint32_t value_type;
//*************************************************************************
/// Default constructor.
/// \param seed The seed value. Default = 0.
//*************************************************************************
murmur3_32(value_type seed = 0)
: seed(seed),
ihash(etl::endian(ENDIANNESS))
{
reset();
}
//*************************************************************************
/// Constructor from range.
/// \param begin Start of the range.
/// \param end End of the range.
/// \param seed The seed value. Default = 0.
//*************************************************************************
template<typename TIterator>
murmur3_32(TIterator begin, const TIterator end, value_type seed = 0)
: seed(seed),
ihash(etl::endian(ENDIANNESS))
{
reset();
add(begin, end);
}
//*************************************************************************
/// Resets the hash to the initial state.
//*************************************************************************
void reset()
{
hash = seed;
char_count = 0;
block = 0;
block_fill_count = 0;
is_finalised = false;
}
//*************************************************************************
/// Adds a range.
/// \param begin
/// \param end
//*************************************************************************
template<typename TIterator>
void add(TIterator begin, const TIterator end)
{
ihash::add(begin, end);
}
//*************************************************************************
/// Adds a value.
/// \param value The value to add to the hash.
//*************************************************************************
template<typename TValue>
void add(TValue value)
{
ihash::add(value);
}
//*************************************************************************
/// Adds a uint8_t value.
/// If the hash has already been finalised then a 'hash_finalised' error will be emitted.
/// \param value The char to add to the hash.
//*************************************************************************
void add(uint8_t value)
{
// We can't add to a finalised hash!
if (is_finalised)
{
#if ETL_THROW_EXCEPTIONS
throw hash_finalised();
#else
error_handler::error(hash_finalised());
#endif
}
else
{
block |= value << (block_fill_count * 8);
if (++block_fill_count == FULL_BLOCK)
{
add_block();
block_fill_count = 0;
block = 0;
}
++char_count;
}
}
//*************************************************************************
/// Gets the hash value.
//*************************************************************************
value_type value()
{
finalise();
return hash;
}
//*************************************************************************
/// Conversion operator to value_type.
//*************************************************************************
operator value_type ()
{
return value();
}
//*************************************************************************
/// Gets the generic digest value.
//*************************************************************************
generic_digest digest()
{
finalise();
return ihash::get_digest(hash);
}
private:
//*************************************************************************
/// Adds a filled block to the hash.
//*************************************************************************
void add_block()
{
block *= CONSTANT1;
block = rotate_left(block, SHIFT1);
block *= CONSTANT2;
hash ^= block;
hash = rotate_left(hash, SHIFT2);
hash = (hash * MULTIPLY) + ADD;
}
//*************************************************************************
/// Finalises the hash.
//*************************************************************************
void finalise()
{
block *= CONSTANT1;
block = rotate_left(block, SHIFT1);
block *= CONSTANT2;
hash ^= block;
hash ^= char_count;
hash ^= (hash >> 16);
hash *= 0x85EBCA6B;
hash ^= (hash >> 13);
hash *= 0xC2B2AE35;
hash ^= (hash >> 16);
is_finalised = true;
}
bool is_finalised;
uint8_t block_fill_count;
size_t char_count;
value_type block;
value_type hash;
value_type seed;
static const uint8_t FULL_BLOCK = 4;
static const value_type CONSTANT1 = 0xCC9E2D51;
static const value_type CONSTANT2 = 0x1B873593;
static const value_type SHIFT1 = 15;
static const value_type SHIFT2 = 13;
static const value_type MULTIPLY = 5;
static const value_type ADD = 0xE6546B64;
};
}
#endif // MURMUR3_H

333
test/murmurhash3.cpp Normal file
View File

@ -0,0 +1,333 @@
//-----------------------------------------------------------------------------
// MurmurHash3 was written by Austin Appleby, and is placed in the public
// domain. The author hereby disclaims copyright to this source code.
// Note - The x86 and x64 versions do _not_ produce the same results, as the
// algorithms are optimized for their respective platforms. You can still
// compile and run any of them on any platform, but your performance with the
// non-native version will be less than optimal.
#include "MurmurHash3.h"
//-----------------------------------------------------------------------------
// Platform-specific functions and macros
// Microsoft Visual Studio
#if defined(_MSC_VER)
#define FORCE_INLINE __forceinline
#include <stdlib.h>
#define ROTL32(x,y) _rotl(x,y)
#define ROTL64(x,y) _rotl64(x,y)
#define BIG_CONSTANT(x) (x)
// Other compilers
#else // defined(_MSC_VER)
#define FORCE_INLINE inline __attribute__((always_inline))
inline uint32_t rotl32(uint32_t x, int8_t r)
{
return (x << r) | (x >> (32 - r));
}
inline uint64_t rotl64(uint64_t x, int8_t r)
{
return (x << r) | (x >> (64 - r));
}
#define ROTL32(x,y) rotl32(x,y)
#define ROTL64(x,y) rotl64(x,y)
#define BIG_CONSTANT(x) (x##LLU)
#endif // !defined(_MSC_VER)
//-----------------------------------------------------------------------------
// Block read - if your platform needs to do endian-swapping or can only
// handle aligned reads, do the conversion here
FORCE_INLINE uint32_t getblock32(const uint32_t * p, int i)
{
return p[i];
}
FORCE_INLINE uint64_t getblock64(const uint64_t * p, int i)
{
return p[i];
}
//-----------------------------------------------------------------------------
// Finalization mix - force all bits of a hash block to avalanche
FORCE_INLINE uint32_t fmix32(uint32_t h)
{
h ^= h >> 16;
h *= 0x85ebca6b;
h ^= h >> 13;
h *= 0xc2b2ae35;
h ^= h >> 16;
return h;
}
//----------
FORCE_INLINE uint64_t fmix64(uint64_t k)
{
k ^= k >> 33;
k *= BIG_CONSTANT(0xff51afd7ed558ccd);
k ^= k >> 33;
k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
k ^= k >> 33;
return k;
}
//-----------------------------------------------------------------------------
void MurmurHash3_x86_32(const void * key, int len,
uint32_t seed, void * out)
{
const uint8_t * data = (const uint8_t*)key;
const int nblocks = len / 4;
uint32_t h1 = seed;
const uint32_t c1 = 0xcc9e2d51;
const uint32_t c2 = 0x1b873593;
//----------
// body
const uint32_t * blocks = (const uint32_t *)(data + nblocks * 4);
for (int i = -nblocks; i; i++)
{
uint32_t k1 = getblock32(blocks, i);
k1 *= c1;
k1 = ROTL32(k1, 15);
k1 *= c2;
h1 ^= k1;
h1 = ROTL32(h1, 13);
h1 = h1 * 5 + 0xe6546b64;
}
//----------
// tail
const uint8_t * tail = (const uint8_t*)(data + nblocks * 4);
uint32_t k1 = 0;
switch (len & 3)
{
case 3: k1 ^= tail[2] << 16;
case 2: k1 ^= tail[1] << 8;
case 1: k1 ^= tail[0];
k1 *= c1; k1 = ROTL32(k1, 15); k1 *= c2; h1 ^= k1;
};
//----------
// finalization
h1 ^= len;
h1 = fmix32(h1);
*(uint32_t*)out = h1;
}
//-----------------------------------------------------------------------------
void MurmurHash3_x86_128(const void * key, const int len,
uint32_t seed, void * out)
{
const uint8_t * data = (const uint8_t*)key;
const int nblocks = len / 16;
uint32_t h1 = seed;
uint32_t h2 = seed;
uint32_t h3 = seed;
uint32_t h4 = seed;
const uint32_t c1 = 0x239b961b;
const uint32_t c2 = 0xab0e9789;
const uint32_t c3 = 0x38b34ae5;
const uint32_t c4 = 0xa1e38b93;
//----------
// body
const uint32_t * blocks = (const uint32_t *)(data + nblocks * 16);
for (int i = -nblocks; i; i++)
{
uint32_t k1 = getblock32(blocks, i * 4 + 0);
uint32_t k2 = getblock32(blocks, i * 4 + 1);
uint32_t k3 = getblock32(blocks, i * 4 + 2);
uint32_t k4 = getblock32(blocks, i * 4 + 3);
k1 *= c1; k1 = ROTL32(k1, 15); k1 *= c2; h1 ^= k1;
h1 = ROTL32(h1, 19); h1 += h2; h1 = h1 * 5 + 0x561ccd1b;
k2 *= c2; k2 = ROTL32(k2, 16); k2 *= c3; h2 ^= k2;
h2 = ROTL32(h2, 17); h2 += h3; h2 = h2 * 5 + 0x0bcaa747;
k3 *= c3; k3 = ROTL32(k3, 17); k3 *= c4; h3 ^= k3;
h3 = ROTL32(h3, 15); h3 += h4; h3 = h3 * 5 + 0x96cd1c35;
k4 *= c4; k4 = ROTL32(k4, 18); k4 *= c1; h4 ^= k4;
h4 = ROTL32(h4, 13); h4 += h1; h4 = h4 * 5 + 0x32ac3b17;
}
//----------
// tail
const uint8_t * tail = (const uint8_t*)(data + nblocks * 16);
uint32_t k1 = 0;
uint32_t k2 = 0;
uint32_t k3 = 0;
uint32_t k4 = 0;
switch (len & 15)
{
case 15: k4 ^= tail[14] << 16;
case 14: k4 ^= tail[13] << 8;
case 13: k4 ^= tail[12] << 0;
k4 *= c4; k4 = ROTL32(k4, 18); k4 *= c1; h4 ^= k4;
case 12: k3 ^= tail[11] << 24;
case 11: k3 ^= tail[10] << 16;
case 10: k3 ^= tail[9] << 8;
case 9: k3 ^= tail[8] << 0;
k3 *= c3; k3 = ROTL32(k3, 17); k3 *= c4; h3 ^= k3;
case 8: k2 ^= tail[7] << 24;
case 7: k2 ^= tail[6] << 16;
case 6: k2 ^= tail[5] << 8;
case 5: k2 ^= tail[4] << 0;
k2 *= c2; k2 = ROTL32(k2, 16); k2 *= c3; h2 ^= k2;
case 4: k1 ^= tail[3] << 24;
case 3: k1 ^= tail[2] << 16;
case 2: k1 ^= tail[1] << 8;
case 1: k1 ^= tail[0] << 0;
k1 *= c1; k1 = ROTL32(k1, 15); k1 *= c2; h1 ^= k1;
};
//----------
// finalization
h1 ^= len; h2 ^= len; h3 ^= len; h4 ^= len;
h1 += h2; h1 += h3; h1 += h4;
h2 += h1; h3 += h1; h4 += h1;
h1 = fmix32(h1);
h2 = fmix32(h2);
h3 = fmix32(h3);
h4 = fmix32(h4);
h1 += h2; h1 += h3; h1 += h4;
h2 += h1; h3 += h1; h4 += h1;
((uint32_t*)out)[0] = h1;
((uint32_t*)out)[1] = h2;
((uint32_t*)out)[2] = h3;
((uint32_t*)out)[3] = h4;
}
//-----------------------------------------------------------------------------
void MurmurHash3_x64_128(const void * key, const int len,
const uint32_t seed, void * out)
{
const uint8_t * data = (const uint8_t*)key;
const int nblocks = len / 16;
uint64_t h1 = seed;
uint64_t h2 = seed;
const uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
const uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
//----------
// body
const uint64_t * blocks = (const uint64_t *)(data);
for (int i = 0; i < nblocks; i++)
{
uint64_t k1 = getblock64(blocks, i * 2 + 0);
uint64_t k2 = getblock64(blocks, i * 2 + 1);
k1 *= c1; k1 = ROTL64(k1, 31); k1 *= c2; h1 ^= k1;
h1 = ROTL64(h1, 27); h1 += h2; h1 = h1 * 5 + 0x52dce729;
k2 *= c2; k2 = ROTL64(k2, 33); k2 *= c1; h2 ^= k2;
h2 = ROTL64(h2, 31); h2 += h1; h2 = h2 * 5 + 0x38495ab5;
}
//----------
// tail
const uint8_t * tail = (const uint8_t*)(data + nblocks * 16);
uint64_t k1 = 0;
uint64_t k2 = 0;
switch (len & 15)
{
case 15: k2 ^= ((uint64_t)tail[14]) << 48;
case 14: k2 ^= ((uint64_t)tail[13]) << 40;
case 13: k2 ^= ((uint64_t)tail[12]) << 32;
case 12: k2 ^= ((uint64_t)tail[11]) << 24;
case 11: k2 ^= ((uint64_t)tail[10]) << 16;
case 10: k2 ^= ((uint64_t)tail[9]) << 8;
case 9: k2 ^= ((uint64_t)tail[8]) << 0;
k2 *= c2; k2 = ROTL64(k2, 33); k2 *= c1; h2 ^= k2;
case 8: k1 ^= ((uint64_t)tail[7]) << 56;
case 7: k1 ^= ((uint64_t)tail[6]) << 48;
case 6: k1 ^= ((uint64_t)tail[5]) << 40;
case 5: k1 ^= ((uint64_t)tail[4]) << 32;
case 4: k1 ^= ((uint64_t)tail[3]) << 24;
case 3: k1 ^= ((uint64_t)tail[2]) << 16;
case 2: k1 ^= ((uint64_t)tail[1]) << 8;
case 1: k1 ^= ((uint64_t)tail[0]) << 0;
k1 *= c1; k1 = ROTL64(k1, 31); k1 *= c2; h1 ^= k1;
};
//----------
// finalization
h1 ^= len; h2 ^= len;
h1 += h2;
h2 += h1;
h1 = fmix64(h1);
h2 = fmix64(h2);
h1 += h2;
h2 += h1;
((uint64_t*)out)[0] = h1;
((uint64_t*)out)[1] = h2;
}

38
test/murmurhash3.h Normal file
View File

@ -0,0 +1,38 @@
//-----------------------------------------------------------------------------
// MurmurHash3 was written by Austin Appleby, and is placed in the public
// domain. The author hereby disclaims copyright to this source code.
#ifndef _MURMURHASH3_H_
#define _MURMURHASH3_H_
//-----------------------------------------------------------------------------
// Platform-specific functions and macros
// Microsoft Visual Studio
#if defined(_MSC_VER) && (_MSC_VER < 1600)
typedef unsigned char uint8_t;
typedef unsigned int uint32_t;
typedef unsigned __int64 uint64_t;
// Other compilers
#else // defined(_MSC_VER)
#include <stdint.h>
#endif // !defined(_MSC_VER)
//-----------------------------------------------------------------------------
void MurmurHash3_x86_32(const void * key, int len, uint32_t seed, void * out);
void MurmurHash3_x86_128(const void * key, int len, uint32_t seed, void * out);
void MurmurHash3_x64_128(const void * key, int len, uint32_t seed, void * out);
//-----------------------------------------------------------------------------
#endif // _MURMURHASH3_H_

264
test/test_bsd_checksum.cpp Normal file
View File

@ -0,0 +1,264 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
Copyright(c) 2014 jwellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include <UnitTest++/UnitTest++.h>
#include <iterator>
#include <string>
#include <vector>
#include <stdint.h>
#include "../bsd_checksum.h"
#include "../endian.h"
template <typename TSum, typename TIterator>
TSum reference_checksum(TIterator begin, TIterator end)
{
TSum checksum = 0;
while (begin != end)
{
checksum = etl::rotate_right(checksum);
checksum += *begin;
}
return checksum;
}
namespace
{
SUITE(test_checksum)
{
//*************************************************************************
TEST(test_checksum_constructor)
{
std::string data("123456789");
uint8_t sum = etl::bsd_checksum<uint8_t>(data.begin(), data.end());
uint8_t compare = reference_checksum<uint8_t>(data.begin(), data.end());
CHECK_EQUAL(compare, sum);
}
//*************************************************************************
TEST(test_checksum_add_values8_add)
{
std::string data("123456789");
etl::bsd_checksum<uint8_t> checksum_calculator;
for (size_t i = 0; i < data.size(); ++i)
{
checksum_calculator.add(data[i]);
}
uint8_t sum = checksum_calculator;
uint8_t compare = reference_checksum<uint8_t>(data.begin(), data.end());
CHECK_EQUAL(compare, sum);
}
//*************************************************************************
TEST(test_checksum_add_values8_operator_plus_equals)
{
std::string data("123456789");
etl::bsd_checksum<uint8_t> checksum_calculator;
for (size_t i = 0; i < data.size(); ++i)
{
checksum_calculator += data[i];
}
uint8_t sum = checksum_calculator;
uint8_t compare = reference_checksum<uint8_t>(data.begin(), data.end());
CHECK_EQUAL(compare, sum);
}
//*************************************************************************
TEST(test_checksum_add_values8_operator_stream)
{
std::string data("123456789");
etl::bsd_checksum<uint8_t> checksum_calculator;
for (size_t i = 0; i < data.size(); ++i)
{
checksum_calculator << data[i];
}
uint8_t sum = checksum_calculator;
uint8_t compare = reference_checksum<uint8_t>(data.begin(), data.end());
CHECK_EQUAL(compare, sum);
}
//*************************************************************************
TEST(test_checksum_add_values32_add)
{
std::vector<uint32_t> data = { 0x04030201, 0x08070605 };
etl::bsd_checksum<uint32_t> checksum_calculator;
for (size_t i = 0; i < data.size(); ++i)
{
checksum_calculator += data[i];
}
uint32_t sum = checksum_calculator;
uint32_t compare = reference_checksum<uint32_t>(data.begin(), data.end());
CHECK_EQUAL(compare, sum);
}
//*************************************************************************
TEST(test_checksum_add_values32_plus_equals)
{
std::vector<uint32_t> data = { 0x04030201, 0x08070605 };
etl::bsd_checksum<uint32_t> checksum_calculator;
for (size_t i = 0; i < data.size(); ++i)
{
checksum_calculator.add(data[i]);
}
uint32_t sum = checksum_calculator;
uint32_t compare = reference_checksum<uint32_t>(data.begin(), data.end());
CHECK_EQUAL(compare, sum);
}
//*************************************************************************
TEST(test_checksum_add_values32_operator_stream)
{
std::vector<uint32_t> data = { 0x04030201, 0x08070605 };
etl::bsd_checksum<uint32_t> checksum_calculator;
for (size_t i = 0; i < data.size(); ++i)
{
checksum_calculator << data[i];
}
uint32_t sum = checksum_calculator;
uint32_t compare = reference_checksum<uint32_t>(data.begin(), data.end());
CHECK_EQUAL(compare, sum);
}
//*************************************************************************
TEST(test_checksum_add_range)
{
std::string data("123456789");
etl::bsd_checksum<uint8_t> checksum_calculator;
checksum_calculator.add(data.begin(), data.end());
uint8_t sum = checksum_calculator.value();
uint8_t compare = reference_checksum<uint8_t>(data.begin(), data.end());
CHECK_EQUAL(compare, sum);
}
//*************************************************************************
TEST(test_checksum_add_range_sum32)
{
std::string data("123456789");
etl::bsd_checksum<uint32_t> checksum_calculator;
checksum_calculator.add(data.begin(), data.end());
uint32_t sum = checksum_calculator.value();
uint32_t compare = reference_checksum<uint8_t>(data.begin(), data.end());
CHECK_EQUAL(compare, sum);
}
//*************************************************************************
TEST(test_checksum_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
std::vector<uint32_t> data2 = { 0x04030201, 0x08070605 };
std::vector<uint32_t> data3 = { 0x01020304, 0x05060708 };
uint8_t sum1 = etl::bsd_checksum<uint8_t, etl::endian::little>(data1.begin(), data1.end());
uint8_t sum2 = etl::bsd_checksum<uint8_t, etl::endian::little>(data2.begin(), data2.end());
CHECK_EQUAL(int(sum1), int(sum2));
uint8_t sum3 = etl::bsd_checksum<uint8_t, etl::endian::big>(data3.begin(), data3.end());
CHECK_EQUAL(int(sum1), int(sum3));
}
//*************************************************************************
TEST(test_checksum_add_double)
{
double d = 3.1415927;
etl::bsd_checksum<uint8_t> checksum_calculator;
checksum_calculator << d;
uint8_t sum = checksum_calculator.value();
CHECK_EQUAL(165, int(sum));
}
//*************************************************************************
TEST(test_digest)
{
std::string data("123456789");
etl::bsd_checksum<uint8_t> checksum_calculator8(data.begin(), data.end());
etl::bsd_checksum<uint16_t> checksum_calculator16(data.begin(), data.end());
etl::bsd_checksum<uint32_t> checksum_calculator32(data.begin(), data.end());
etl::bsd_checksum<uint64_t> checksum_calculator64(data.begin(), data.end());
etl::ihash::generic_digest digest;
digest = checksum_calculator8.digest();
CHECK_EQUAL(221, *digest.first);
CHECK_EQUAL(sizeof(uint8_t), std::distance(digest.first, digest.second));
digest = checksum_calculator16.digest();
CHECK_EQUAL(477, *reinterpret_cast<const uint16_t*>(digest.first));
CHECK_EQUAL(sizeof(uint16_t), std::distance(digest.first, digest.second));
digest = checksum_calculator32.digest();
CHECK_EQUAL(477, *reinterpret_cast<const uint32_t*>(digest.first));
CHECK_EQUAL(sizeof(uint32_t), std::distance(digest.first, digest.second));
digest = checksum_calculator64.digest();
CHECK_EQUAL(477, *reinterpret_cast<const uint64_t*>(digest.first));
CHECK_EQUAL(sizeof(uint64_t), std::distance(digest.first, digest.second));
}
};
}

121
test/test_murmur3.cpp Normal file
View File

@ -0,0 +1,121 @@
/******************************************************************************
The MIT License(MIT)
Embedded Template Library.
https://github.com/ETLCPP/etl
Copyright(c) 2014 jwellbelove
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files(the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions :
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
******************************************************************************/
#include <UnitTest++/UnitTest++.h>
#include "murmurhash3.h" // The 'C' reference implementation.
#include <iterator>
#include <string>
#include <vector>
#include <stdint.h>
#include "../murmur3.h"
#include "../endian.h"
namespace
{
SUITE(test_murmur3)
{
//*************************************************************************
TEST(test_murmur3_32_constructor)
{
std::string data("123456789");
uint32_t hash = etl::murmur3_32<>(data.begin(), data.end());
uint32_t compare;
MurmurHash3_x86_32(data.c_str(), data.size(), 0, &compare);
CHECK_EQUAL(compare, hash);
}
//*************************************************************************
TEST(test_murmur3_32_add_values)
{
std::string data("123456789");
etl::murmur3_32<> murmur3_32_calculator;
for (size_t i = 0; i < data.size(); ++i)
{
murmur3_32_calculator += data[i];
}
uint32_t hash = murmur3_32_calculator;
uint32_t compare;
MurmurHash3_x86_32(data.c_str(), data.size(), 0, &compare);
CHECK_EQUAL(compare, hash);
}
//*************************************************************************
TEST(test_murmur3_32_add_range)
{
std::string data("123456789");
etl::murmur3_32<> murmur3_32_calculator;
murmur3_32_calculator.add(data.begin(), data.end());
uint32_t hash = murmur3_32_calculator.value();
uint32_t compare;
MurmurHash3_x86_32(data.c_str(), data.size(), 0, &compare);
CHECK_EQUAL(compare, hash);
}
//*************************************************************************
TEST(test_murmur3_32_add_range_endian)
{
std::vector<uint8_t> data1 = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 };
std::vector<uint32_t> data2 = { 0x04030201, 0x08070605 };
std::vector<uint32_t> data3 = { 0x01020304, 0x05060708 };
uint32_t hash1 = etl::murmur3_32<etl::endian::little>(data1.begin(), data1.end());
uint32_t hash2 = etl::murmur3_32<etl::endian::little>(data2.begin(), data2.end());
uint32_t hash3 = etl::murmur3_32<etl::endian::big>(data3.begin(), data3.end());
CHECK_EQUAL(hash1, hash2);
CHECK_EQUAL(hash1, hash3);
uint32_t compare1;
MurmurHash3_x86_32(&data1[0], data1.size(), 0, &compare1);
CHECK_EQUAL(compare1, hash1);
uint32_t compare2;
MurmurHash3_x86_32(&data2[0], data2.size() * sizeof(uint32_t), 0, &compare2);
CHECK_EQUAL(compare2, hash2);
uint32_t compare3;
MurmurHash3_x86_32(&data3[0], data3.size() * sizeof(uint32_t), 0, &compare3);
CHECK_EQUAL(compare2, hash3);
}
};
}

22
test/vs2015/etl.sln Normal file
View File

@ -0,0 +1,22 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Express 2013 for Windows Desktop
VisualStudioVersion = 12.0.21005.1
MinimumVisualStudioVersion = 10.0.40219.1
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "etl", "etl.vcxproj", "{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Win32 = Debug|Win32
Release|Win32 = Release|Win32
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug|Win32.ActiveCfg = Debug|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Debug|Win32.Build.0 = Debug|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release|Win32.ActiveCfg = Release|Win32
{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}.Release|Win32.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

320
test/vs2015/etl.vcxproj Normal file
View File

@ -0,0 +1,320 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{C21DF78C-D8E0-46AB-9D6F-D38A3C1CB0FB}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>unittest</RootNamespace>
<ProjectName>etl</ProjectName>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v140</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;ETL_THROW_EXCEPTIONS;PLATFORM_WINDOWS;COMPILER_MICROSOFT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>../../../unittest-cpp</AdditionalIncludeDirectories>
<UndefinePreprocessorDefinitions>
</UndefinePreprocessorDefinitions>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
<PostBuildEvent>
<Command>$(OutDir)\etl.exe</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;_LIB;_CRT_SECURE_NO_WARNINGS;_SCL_SECURE_NO_WARNINGS;ETL_THROW_EXCEPTIONS;PLATFORM_WINDOWS;COMPILER_MICROSOFT;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<AdditionalIncludeDirectories>../../../unittest-cpp</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
<PostBuildEvent>
<Command>$(OutDir)\etl.exe</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\AssertException.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\CheckMacros.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\Checks.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\CompositeTestReporter.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\Config.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\CurrentTest.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\DeferredTestReporter.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\DeferredTestResult.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\ExceptionMacros.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\ExecuteTest.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\HelperMacros.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\MemoryOutStream.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\ReportAssert.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\ReportAssertImpl.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\Test.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestDetails.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestList.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestMacros.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestReporter.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestReporterStdout.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestResults.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestRunner.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestSuite.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TimeConstraint.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TimeHelpers.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\UnitTest++.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\UnitTestPP.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\Win32\TimeHelpers.h" />
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\XmlTestReporter.h" />
<ClInclude Include="..\..\algorithm.h" />
<ClInclude Include="..\..\alignment.h" />
<ClInclude Include="..\..\array.h" />
<ClInclude Include="..\..\binary.h" />
<ClInclude Include="..\..\bitset.h" />
<ClInclude Include="..\..\bloom_filter.h" />
<ClInclude Include="..\..\checksum.h" />
<ClInclude Include="..\..\crc16.h" />
<ClInclude Include="..\..\crc16_ccitt.h" />
<ClInclude Include="..\..\crc16_kermit.h" />
<ClInclude Include="..\..\crc32.h" />
<ClInclude Include="..\..\crc64_ecma.h" />
<ClInclude Include="..\..\crc8_ccitt.h" />
<ClInclude Include="..\..\cyclic_value.h" />
<ClInclude Include="..\..\deque.h" />
<ClInclude Include="..\..\deque_base.h" />
<ClInclude Include="..\..\doxygen.h" />
<ClInclude Include="..\..\endian.h" />
<ClInclude Include="..\..\enum_type.h" />
<ClInclude Include="..\..\error_handler.h" />
<ClInclude Include="..\..\etlhash.h" />
<ClInclude Include="..\..\exception.h" />
<ClInclude Include="..\..\factorial.h" />
<ClInclude Include="..\..\fibonacci.h" />
<ClInclude Include="..\..\fixed_iterator.h" />
<ClInclude Include="..\..\flat_set.h" />
<ClInclude Include="..\..\flat_set_base.h" />
<ClInclude Include="..\..\fnv_1.h" />
<ClInclude Include="..\..\forward_list.h" />
<ClInclude Include="..\..\forward_list_base.h" />
<ClInclude Include="..\..\function.h" />
<ClInclude Include="..\..\functional.h" />
<ClInclude Include="..\..\hash.h" />
<ClInclude Include="..\..\ibitset.h" />
<ClInclude Include="..\..\ideque.h" />
<ClInclude Include="..\..\iflat_set.h" />
<ClInclude Include="..\..\iforward_list.h" />
<ClInclude Include="..\..\ihash.h" />
<ClInclude Include="..\..\ilist.h" />
<ClInclude Include="..\..\iflat_map.h" />
<ClInclude Include="..\..\ilru_cache.h" />
<ClInclude Include="..\..\imap.h" />
<ClInclude Include="..\..\imru_cache.h" />
<ClInclude Include="..\..\imultimap.h" />
<ClInclude Include="..\..\imultiset.h" />
<ClInclude Include="..\..\instance_count.h" />
<ClInclude Include="..\..\integral_limits.h" />
<ClInclude Include="..\..\io_port.h" />
<ClInclude Include="..\..\ipool.h" />
<ClInclude Include="..\..\ipriority_queue.h" />
<ClInclude Include="..\..\iqueue.h" />
<ClInclude Include="..\..\irr_cache.h" />
<ClInclude Include="..\..\iset.h" />
<ClInclude Include="..\..\istack.h" />
<ClInclude Include="..\..\container.h" />
<ClInclude Include="..\..\iunordered_map.h" />
<ClInclude Include="..\..\ivector.h" />
<ClInclude Include="..\..\largest.h" />
<ClInclude Include="..\..\list.h" />
<ClInclude Include="..\..\list_base.h" />
<ClInclude Include="..\..\log.h" />
<ClInclude Include="..\..\flat_map.h" />
<ClInclude Include="..\..\flat_map_base.h" />
<ClInclude Include="..\..\lru_cache.h" />
<ClInclude Include="..\..\map.h" />
<ClInclude Include="..\..\map_base.h" />
<ClInclude Include="..\..\mru_cache.h" />
<ClInclude Include="..\..\multimap.h" />
<ClInclude Include="..\..\multiset.h" />
<ClInclude Include="..\..\murmur3.h" />
<ClInclude Include="..\..\nullptr.h" />
<ClInclude Include="..\..\numeric.h" />
<ClInclude Include="..\..\observer.h" />
<ClInclude Include="..\..\optional.h" />
<ClInclude Include="..\..\parameter_type.h" />
<ClInclude Include="..\..\pool.h" />
<ClInclude Include="..\..\pool_base.h" />
<ClInclude Include="..\..\power.h" />
<ClInclude Include="..\..\priority_queue.h" />
<ClInclude Include="..\..\priority_queue_base.h" />
<ClInclude Include="..\..\queue.h" />
<ClInclude Include="..\..\queue_base.h" />
<ClInclude Include="..\..\radix.h" />
<ClInclude Include="..\..\rr_cache.h" />
<ClInclude Include="..\..\set.h" />
<ClInclude Include="..\..\set_base.h" />
<ClInclude Include="..\..\smallest.h" />
<ClInclude Include="..\..\stack.h" />
<ClInclude Include="..\..\stack_base.h" />
<ClInclude Include="..\..\static_assert.h" />
<ClInclude Include="..\..\type_traits.h" />
<ClInclude Include="..\..\unordered_map.h" />
<ClInclude Include="..\..\unordered_map_base.h" />
<ClInclude Include="..\..\variant.h" />
<ClInclude Include="..\..\vector.h" />
<ClInclude Include="..\..\vector_base.h" />
<ClInclude Include="..\..\visitor.h" />
<ClInclude Include="..\data.h" />
<ClInclude Include="..\ExtraCheckMacros.h" />
<ClInclude Include="..\murmurhash3.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\AssertException.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\Checks.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\CompositeTestReporter.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\CurrentTest.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\DeferredTestReporter.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\DeferredTestResult.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\MemoryOutStream.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\ReportAssert.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\Test.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestDetails.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestList.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestReporter.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestReporterStdout.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestResults.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestRunner.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TimeConstraint.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\Win32\TimeHelpers.cpp" />
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\XmlTestReporter.cpp" />
<ClCompile Include="..\..\crc16.cpp" />
<ClCompile Include="..\..\crc16_ccitt.cpp" />
<ClCompile Include="..\..\crc16_kermit.cpp" />
<ClCompile Include="..\..\crc32.cpp" />
<ClCompile Include="..\..\crc64_ecma.cpp" />
<ClCompile Include="..\..\crc8_ccitt.cpp" />
<ClCompile Include="..\..\error_handler.cpp" />
<ClCompile Include="..\main.cpp" />
<ClCompile Include="..\murmurhash3.cpp" />
<ClCompile Include="..\test_algorithm.cpp" />
<ClCompile Include="..\test_alignment.cpp" />
<ClCompile Include="..\test_array.cpp">
<AdditionalIncludeDirectories Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">../../../unittest-cpp</AdditionalIncludeDirectories>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\test_binary.cpp" />
<ClCompile Include="..\test_bitset.cpp" />
<ClCompile Include="..\test_bloom_filter.cpp" />
<ClCompile Include="..\test_checksum.cpp" />
<ClCompile Include="..\test_container.cpp" />
<ClCompile Include="..\test_crc.cpp" />
<ClCompile Include="..\test_cyclic_value.cpp" />
<ClCompile Include="..\test_deque.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\test_endian.cpp" />
<ClCompile Include="..\test_enum_type.cpp" />
<ClCompile Include="..\test_error_handler.cpp" />
<ClCompile Include="..\test_exception.cpp" />
<ClCompile Include="..\test_fixed_iterator.cpp" />
<ClCompile Include="..\test_flat_set.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\test_fnv_1.cpp" />
<ClCompile Include="..\test_forward_list.cpp" />
<ClCompile Include="..\test_function.cpp" />
<ClCompile Include="..\test_functional.cpp" />
<ClCompile Include="..\test_hash.cpp" />
<ClCompile Include="..\test_instance_count.cpp" />
<ClCompile Include="..\test_integral_limits.cpp" />
<ClCompile Include="..\test_io_port.cpp" />
<ClCompile Include="..\test_largest.cpp" />
<ClCompile Include="..\test_list.cpp" />
<ClCompile Include="..\test_flat_map.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\test_map.cpp" />
<ClCompile Include="..\test_maths.cpp" />
<ClCompile Include="..\test_multimap.cpp" />
<ClCompile Include="..\test_multiset.cpp" />
<ClCompile Include="..\test_murmur3.cpp" />
<ClCompile Include="..\test_numeric.cpp" />
<ClCompile Include="..\test_observer.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\test_optional.cpp" />
<ClCompile Include="..\test_pool.cpp" />
<ClCompile Include="..\test_priority_queue.cpp" />
<ClCompile Include="..\test_queue.cpp" />
<ClCompile Include="..\test_set.cpp" />
<ClCompile Include="..\test_smallest.cpp" />
<ClCompile Include="..\test_stack.cpp" />
<ClCompile Include="..\test_type_traits.cpp" />
<ClCompile Include="..\test_unordered_map.cpp">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="..\test_variant.cpp" />
<ClCompile Include="..\test_vector.cpp" />
<ClCompile Include="..\test_visitor.cpp" />
</ItemGroup>
<ItemGroup>
<None Include="..\..\Doxyfile" />
<None Include="ClassDiagram.cd" />
<None Include="ClassDiagram1.cd" />
<None Include="ClassDiagram2.cd" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

659
test/vs2015/etl.vcxproj.filters Normal file
View File

@ -0,0 +1,659 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="Resource Files">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
<Filter Include="UnitTest++">
<UniqueIdentifier>{ecfaf316-dc6d-4dc1-9838-24061047ad63}</UniqueIdentifier>
</Filter>
<Filter Include="ETL">
<UniqueIdentifier>{53c3a373-0496-4db0-a981-86bf14a1fac9}</UniqueIdentifier>
</Filter>
<Filter Include="UnitTest++\Win32">
<UniqueIdentifier>{107d7e33-580f-4dc5-be11-a4b2076c2c10}</UniqueIdentifier>
</Filter>
<Filter Include="ETL\Containers">
<UniqueIdentifier>{dc39d09c-75c9-453f-8feb-9631a200c0f4}</UniqueIdentifier>
</Filter>
<Filter Include="ETL\Utilities">
<UniqueIdentifier>{ab41d19f-82fe-4974-a73b-16aebfa1d03f}</UniqueIdentifier>
</Filter>
<Filter Include="ETL\Patterns">
<UniqueIdentifier>{d56ca96b-66e1-46cb-83fd-1cd72c51d962}</UniqueIdentifier>
</Filter>
<Filter Include="ETL\Maths">
<UniqueIdentifier>{1c55dd7d-c04b-428c-810b-dd3a08fc4c65}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\AssertException.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\CheckMacros.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\Checks.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\CompositeTestReporter.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\Config.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\CurrentTest.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\DeferredTestReporter.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\DeferredTestResult.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\ExceptionMacros.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\ExecuteTest.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\HelperMacros.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\MemoryOutStream.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\ReportAssert.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\ReportAssertImpl.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\Test.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestDetails.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestList.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestMacros.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestReporter.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestReporterStdout.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestResults.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestRunner.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TestSuite.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TimeConstraint.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\TimeHelpers.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\UnitTest++.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\UnitTestPP.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\XmlTestReporter.h">
<Filter>UnitTest++</Filter>
</ClInclude>
<ClInclude Include="..\..\..\unittest-cpp\UnitTest++\Win32\TimeHelpers.h">
<Filter>UnitTest++\Win32</Filter>
</ClInclude>
<ClInclude Include="..\..\doxygen.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\enum_type.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\exception.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\function.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\array.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\iqueue.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\istack.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\container.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\ivector.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\queue.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\queue_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\stack.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\stack_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\vector.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\vector_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\largest.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\nullptr.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\numeric.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\cyclic_value.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\static_assert.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\type_traits.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\visitor.h">
<Filter>ETL\Patterns</Filter>
</ClInclude>
<ClInclude Include="..\..\observer.h">
<Filter>ETL\Patterns</Filter>
</ClInclude>
<ClInclude Include="..\..\functional.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\list.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\ilist.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\list_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\map.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\imap.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\map_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\crc16.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\crc16_ccitt.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\crc32.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\crc64_ecma.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\crc8_ccitt.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\log.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\deque.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\deque_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\ideque.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\ExtraCheckMacros.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\forward_list.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\forward_list_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\iforward_list.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\bitset.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\smallest.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\integral_limits.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\variant.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\crc16_kermit.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\endian.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\parameter_type.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\alignment.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\pool.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\power.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\fibonacci.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\factorial.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\algorithm.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\error_handler.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\instance_count.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\checksum.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\fnv_1.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\hash.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\ipool.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\pool_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\radix.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\ibitset.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\data.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\bloom_filter.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\fixed_iterator.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\binary.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\flat_map.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\iflat_map.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\flat_map_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\ihash.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\flat_set.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\flat_set_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\iflat_set.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\unordered_map.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\iunordered_map.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\unordered_map_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\io_port.h">
<Filter>ETL\Utilities</Filter>
</ClInclude>
<ClInclude Include="..\..\optional.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\iset.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\set.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\set_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\imultimap.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\multimap.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\imultiset.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\multiset.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\ipriority_queue.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\priority_queue.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\priority_queue_base.h">
<Filter>ETL\Containers</Filter>
</ClInclude>
<ClInclude Include="..\..\ilru_cache.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\imru_cache.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\irr_cache.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\lru_cache.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\mru_cache.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\rr_cache.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\etlhash.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\..\murmur3.h">
<Filter>ETL\Maths</Filter>
</ClInclude>
<ClInclude Include="..\murmurhash3.h">
<Filter>Source Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\AssertException.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\Checks.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\CompositeTestReporter.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\CurrentTest.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\DeferredTestReporter.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\DeferredTestResult.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\MemoryOutStream.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\ReportAssert.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\Test.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestDetails.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestList.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestReporter.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestReporterStdout.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestResults.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TestRunner.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\TimeConstraint.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\XmlTestReporter.cpp">
<Filter>UnitTest++</Filter>
</ClCompile>
<ClCompile Include="..\..\..\unittest-cpp\UnitTest++\Win32\TimeHelpers.cpp">
<Filter>UnitTest++\Win32</Filter>
</ClCompile>
<ClCompile Include="..\main.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_array.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_enum_type.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_exception.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_function.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_queue.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_stack.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_vector.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_largest.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_numeric.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_container.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_type_traits.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_cyclic_value.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_visitor.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_list.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_map.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_crc.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\crc16.cpp">
<Filter>ETL\Maths</Filter>
</ClCompile>
<ClCompile Include="..\..\crc16_ccitt.cpp">
<Filter>ETL\Maths</Filter>
</ClCompile>
<ClCompile Include="..\..\crc32.cpp">
<Filter>ETL\Maths</Filter>
</ClCompile>
<ClCompile Include="..\..\crc64_ecma.cpp">
<Filter>ETL\Maths</Filter>
</ClCompile>
<ClCompile Include="..\..\crc8_ccitt.cpp">
<Filter>ETL\Maths</Filter>
</ClCompile>
<ClCompile Include="..\test_deque.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_integral_limits.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_bitset.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_variant.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\crc16_kermit.cpp">
<Filter>ETL\Maths</Filter>
</ClCompile>
<ClCompile Include="..\test_smallest.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_maths.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_alignment.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_pool.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_algorithm.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\error_handler.cpp">
<Filter>ETL\Utilities</Filter>
</ClCompile>
<ClCompile Include="..\test_error_handler.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_functional.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_instance_count.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_checksum.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_fnv_1.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_hash.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_endian.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_bloom_filter.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_forward_list.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_fixed_iterator.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_binary.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_flat_map.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_flat_set.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_observer.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_io_port.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_unordered_map.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_optional.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_set.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_multimap.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_multiset.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_priority_queue.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\test_murmur3.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\murmurhash3.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<None Include="..\..\Doxyfile">
<Filter>Header Files</Filter>
</None>
<None Include="ClassDiagram.cd" />
<None Include="ClassDiagram1.cd" />
<None Include="ClassDiagram2.cd" />
</ItemGroup>
</Project>

291419
test/words.txt Normal file
View File

File diff suppressed because it is too large Load Diff