Fix the test for partition_copy so it is not ridiculously slow. Also, detab.
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@346104 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Marshall Clow
@@ -8,18 +8,18 @@
|
|||||||
//
|
//
|
||||||
//===----------------------------------------------------------------------===//
|
//===----------------------------------------------------------------------===//
|
||||||
|
|
||||||
// A set of routines to use when fuzzing the algorithms in libc++
|
// A set of routines to use when fuzzing the algorithms in libc++
|
||||||
// Each one tests a single algorithm.
|
// Each one tests a single algorithm.
|
||||||
//
|
//
|
||||||
// They all have the form of:
|
// They all have the form of:
|
||||||
// int `algorithm`(const uint8_t *data, size_t size);
|
// int `algorithm`(const uint8_t *data, size_t size);
|
||||||
//
|
//
|
||||||
// They perform the operation, and then check to see if the results are correct.
|
// They perform the operation, and then check to see if the results are correct.
|
||||||
// If so, they return zero, and non-zero otherwise.
|
// If so, they return zero, and non-zero otherwise.
|
||||||
//
|
//
|
||||||
// For example, sort calls std::sort, then checks two things:
|
// For example, sort calls std::sort, then checks two things:
|
||||||
// (1) The resulting vector is sorted
|
// (1) The resulting vector is sorted
|
||||||
// (2) The resulting vector contains the same elements as the original data.
|
// (2) The resulting vector contains the same elements as the original data.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
@@ -32,574 +32,587 @@
|
|||||||
|
|
||||||
#include <iostream>
|
#include <iostream>
|
||||||
|
|
||||||
// If we had C++14, we could use the four iterator version of is_permutation and equal
|
// If we had C++14, we could use the four iterator version of is_permutation and equal
|
||||||
|
|
||||||
namespace fuzzing {
|
namespace fuzzing {
|
||||||
|
|
||||||
// This is a struct we can use to test the stable_XXX algorithms.
|
// This is a struct we can use to test the stable_XXX algorithms.
|
||||||
// perform the operation on the key, then check the order of the payload.
|
// perform the operation on the key, then check the order of the payload.
|
||||||
|
|
||||||
struct stable_test {
|
struct stable_test {
|
||||||
uint8_t key;
|
uint8_t key;
|
||||||
size_t payload;
|
size_t payload;
|
||||||
|
|
||||||
stable_test(uint8_t k) : key(k), payload(0) {}
|
stable_test(uint8_t k) : key(k), payload(0) {}
|
||||||
stable_test(uint8_t k, size_t p) : key(k), payload(p) {}
|
stable_test(uint8_t k, size_t p) : key(k), payload(p) {}
|
||||||
};
|
};
|
||||||
|
|
||||||
void swap(stable_test &lhs, stable_test &rhs)
|
void swap(stable_test &lhs, stable_test &rhs)
|
||||||
{
|
{
|
||||||
using std::swap;
|
using std::swap;
|
||||||
swap(lhs.key, rhs.key);
|
swap(lhs.key, rhs.key);
|
||||||
swap(lhs.payload, rhs.payload);
|
swap(lhs.payload, rhs.payload);
|
||||||
}
|
}
|
||||||
|
|
||||||
struct key_less
|
struct key_less
|
||||||
{
|
{
|
||||||
bool operator () (const stable_test &lhs, const stable_test &rhs) const
|
bool operator () (const stable_test &lhs, const stable_test &rhs) const
|
||||||
{
|
{
|
||||||
return lhs.key < rhs.key;
|
return lhs.key < rhs.key;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
struct payload_less
|
struct payload_less
|
||||||
{
|
{
|
||||||
bool operator () (const stable_test &lhs, const stable_test &rhs) const
|
bool operator () (const stable_test &lhs, const stable_test &rhs) const
|
||||||
{
|
{
|
||||||
return lhs.payload < rhs.payload;
|
return lhs.payload < rhs.payload;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
struct total_less
|
struct total_less
|
||||||
{
|
{
|
||||||
bool operator () (const stable_test &lhs, const stable_test &rhs) const
|
bool operator () (const stable_test &lhs, const stable_test &rhs) const
|
||||||
{
|
{
|
||||||
return lhs.key == rhs.key ? lhs.payload < rhs.payload : lhs.key < rhs.key;
|
return lhs.key == rhs.key ? lhs.payload < rhs.payload : lhs.key < rhs.key;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
bool operator==(const stable_test &lhs, const stable_test &rhs)
|
bool operator==(const stable_test &lhs, const stable_test &rhs)
|
||||||
{
|
{
|
||||||
return lhs.key == rhs.key && lhs.payload == rhs.payload;
|
return lhs.key == rhs.key && lhs.payload == rhs.payload;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
template<typename T>
|
template<typename T>
|
||||||
struct is_even
|
struct is_even
|
||||||
{
|
{
|
||||||
bool operator () (const T &t) const
|
bool operator () (const T &t) const
|
||||||
{
|
{
|
||||||
return t % 2 == 0;
|
return t % 2 == 0;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
||||||
template<>
|
template<>
|
||||||
struct is_even<stable_test>
|
struct is_even<stable_test>
|
||||||
{
|
{
|
||||||
bool operator () (const stable_test &t) const
|
bool operator () (const stable_test &t) const
|
||||||
{
|
{
|
||||||
return t.key % 2 == 0;
|
return t.key % 2 == 0;
|
||||||
}
|
}
|
||||||
};
|
};
|
||||||
|
|
||||||
typedef std::vector<uint8_t> Vec;
|
typedef std::vector<uint8_t> Vec;
|
||||||
typedef std::vector<stable_test> StableVec;
|
typedef std::vector<stable_test> StableVec;
|
||||||
typedef StableVec::const_iterator SVIter;
|
typedef StableVec::const_iterator SVIter;
|
||||||
|
|
||||||
// Cheap version of is_permutation
|
// Cheap version of is_permutation
|
||||||
// Builds a set of buckets for each of the key values.
|
// Builds a set of buckets for each of the key values.
|
||||||
// Sums all the payloads.
|
// Sums all the payloads.
|
||||||
// Not 100% perfect, but _way_ faster
|
// Not 100% perfect, but _way_ faster
|
||||||
bool is_permutation(SVIter first1, SVIter last1, SVIter first2)
|
bool is_permutation(SVIter first1, SVIter last1, SVIter first2)
|
||||||
{
|
{
|
||||||
size_t xBuckets[256] = {0};
|
size_t xBuckets[256] = {0};
|
||||||
size_t xPayloads[256] = {0};
|
size_t xPayloads[256] = {0};
|
||||||
size_t yBuckets[256] = {0};
|
size_t yBuckets[256] = {0};
|
||||||
size_t yPayloads[256] = {0};
|
size_t yPayloads[256] = {0};
|
||||||
|
|
||||||
for (; first1 != last1; ++first1, ++first2)
|
|
||||||
{
|
|
||||||
xBuckets [first1->key]++;
|
|
||||||
xPayloads[first1->key] += first1->payload;
|
|
||||||
|
|
||||||
yBuckets [first2->key]++;
|
for (; first1 != last1; ++first1, ++first2)
|
||||||
yPayloads[first2->key] += first2->payload;
|
{
|
||||||
}
|
xBuckets [first1->key]++;
|
||||||
|
xPayloads[first1->key] += first1->payload;
|
||||||
for (size_t i = 0; i < 256; ++i)
|
|
||||||
{
|
|
||||||
if (xBuckets[i] != yBuckets[i])
|
|
||||||
return false;
|
|
||||||
if (xPayloads[i] != yPayloads[i])
|
|
||||||
return false;
|
|
||||||
}
|
|
||||||
|
|
||||||
return true;
|
yBuckets [first2->key]++;
|
||||||
|
yPayloads[first2->key] += first2->payload;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (size_t i = 0; i < 256; ++i)
|
||||||
|
{
|
||||||
|
if (xBuckets[i] != yBuckets[i])
|
||||||
|
return false;
|
||||||
|
if (xPayloads[i] != yPayloads[i])
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
template <typename Iter1, typename Iter2>
|
template <typename Iter1, typename Iter2>
|
||||||
bool is_permutation(Iter1 first1, Iter1 last1, Iter2 first2)
|
bool is_permutation(Iter1 first1, Iter1 last1, Iter2 first2)
|
||||||
{
|
{
|
||||||
static_assert((std::is_same<typename std::iterator_traits<Iter1>::value_type, uint8_t>::value), "");
|
static_assert((std::is_same<typename std::iterator_traits<Iter1>::value_type, uint8_t>::value), "");
|
||||||
static_assert((std::is_same<typename std::iterator_traits<Iter2>::value_type, uint8_t>::value), "");
|
static_assert((std::is_same<typename std::iterator_traits<Iter2>::value_type, uint8_t>::value), "");
|
||||||
|
|
||||||
size_t xBuckets[256] = {0};
|
|
||||||
size_t yBuckets[256] = {0};
|
|
||||||
|
|
||||||
for (; first1 != last1; ++first1, ++first2)
|
|
||||||
{
|
|
||||||
xBuckets [*first1]++;
|
|
||||||
yBuckets [*first2]++;
|
|
||||||
}
|
|
||||||
|
|
||||||
for (size_t i = 0; i < 256; ++i)
|
|
||||||
if (xBuckets[i] != yBuckets[i])
|
|
||||||
return false;
|
|
||||||
|
|
||||||
return true;
|
size_t xBuckets[256] = {0};
|
||||||
|
size_t yBuckets[256] = {0};
|
||||||
|
|
||||||
|
for (; first1 != last1; ++first1, ++first2)
|
||||||
|
{
|
||||||
|
xBuckets [*first1]++;
|
||||||
|
yBuckets [*first2]++;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (size_t i = 0; i < 256; ++i)
|
||||||
|
if (xBuckets[i] != yBuckets[i])
|
||||||
|
return false;
|
||||||
|
|
||||||
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
// == sort ==
|
// == sort ==
|
||||||
int sort(const uint8_t *data, size_t size)
|
int sort(const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
Vec working(data, data + size);
|
Vec working(data, data + size);
|
||||||
std::sort(working.begin(), working.end());
|
std::sort(working.begin(), working.end());
|
||||||
|
|
||||||
if (!std::is_sorted(working.begin(), working.end())) return 1;
|
if (!std::is_sorted(working.begin(), working.end())) return 1;
|
||||||
if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
|
if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
// == stable_sort ==
|
// == stable_sort ==
|
||||||
int stable_sort(const uint8_t *data, size_t size)
|
int stable_sort(const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
StableVec input;
|
StableVec input;
|
||||||
for (size_t i = 0; i < size; ++i)
|
for (size_t i = 0; i < size; ++i)
|
||||||
input.push_back(stable_test(data[i], i));
|
input.push_back(stable_test(data[i], i));
|
||||||
StableVec working = input;
|
StableVec working = input;
|
||||||
std::stable_sort(working.begin(), working.end(), key_less());
|
std::stable_sort(working.begin(), working.end(), key_less());
|
||||||
|
|
||||||
if (!std::is_sorted(working.begin(), working.end(), key_less())) return 1;
|
if (!std::is_sorted(working.begin(), working.end(), key_less())) return 1;
|
||||||
auto iter = working.begin();
|
auto iter = working.begin();
|
||||||
while (iter != working.end())
|
while (iter != working.end())
|
||||||
{
|
{
|
||||||
auto range = std::equal_range(iter, working.end(), *iter, key_less());
|
auto range = std::equal_range(iter, working.end(), *iter, key_less());
|
||||||
if (!std::is_sorted(range.first, range.second, total_less())) return 2;
|
if (!std::is_sorted(range.first, range.second, total_less())) return 2;
|
||||||
iter = range.second;
|
iter = range.second;
|
||||||
}
|
}
|
||||||
if (!fuzzing::is_permutation(input.cbegin(), input.cend(), working.cbegin())) return 99;
|
if (!fuzzing::is_permutation(input.cbegin(), input.cend(), working.cbegin())) return 99;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
// == partition ==
|
// == partition ==
|
||||||
int partition(const uint8_t *data, size_t size)
|
int partition(const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
Vec working(data, data + size);
|
Vec working(data, data + size);
|
||||||
auto iter = std::partition(working.begin(), working.end(), is_even<uint8_t>());
|
auto iter = std::partition(working.begin(), working.end(), is_even<uint8_t>());
|
||||||
|
|
||||||
if (!std::all_of (working.begin(), iter, is_even<uint8_t>())) return 1;
|
if (!std::all_of (working.begin(), iter, is_even<uint8_t>())) return 1;
|
||||||
if (!std::none_of(iter, working.end(), is_even<uint8_t>())) return 2;
|
if (!std::none_of(iter, working.end(), is_even<uint8_t>())) return 2;
|
||||||
if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
|
if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
// == partition_copy ==
|
// == partition_copy ==
|
||||||
int partition_copy(const uint8_t *data, size_t size)
|
int partition_copy(const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
Vec v1, v2;
|
Vec v1, v2;
|
||||||
auto iter = std::partition_copy(data, data + size,
|
auto iter = std::partition_copy(data, data + size,
|
||||||
std::back_inserter<Vec>(v1), std::back_inserter<Vec>(v2),
|
std::back_inserter<Vec>(v1), std::back_inserter<Vec>(v2),
|
||||||
is_even<uint8_t>());
|
is_even<uint8_t>());
|
||||||
|
|
||||||
// The two vectors should add up to the original size
|
// The two vectors should add up to the original size
|
||||||
if (v1.size() + v2.size() != size) return 1;
|
if (v1.size() + v2.size() != size) return 1;
|
||||||
|
|
||||||
// All of the even values should be in the first vector, and none in the second
|
// All of the even values should be in the first vector, and none in the second
|
||||||
if (!std::all_of (v1.begin(), v1.end(), is_even<uint8_t>())) return 2;
|
if (!std::all_of (v1.begin(), v1.end(), is_even<uint8_t>())) return 2;
|
||||||
if (!std::none_of(v2.begin(), v2.end(), is_even<uint8_t>())) return 3;
|
if (!std::none_of(v2.begin(), v2.end(), is_even<uint8_t>())) return 3;
|
||||||
|
|
||||||
// Every value in both vectors has to be in the original
|
// Every value in both vectors has to be in the original
|
||||||
for (auto v: v1)
|
|
||||||
if (std::find(data, data + size, v) == data + size) return 4;
|
// Make a copy of the input, and sort it
|
||||||
|
Vec v0{data, data + size};
|
||||||
for (auto v: v2)
|
std::sort(v0.begin(), v0.end());
|
||||||
if (std::find(data, data + size, v) == data + size) return 5;
|
|
||||||
|
// Sort each vector and ensure that all of the elements appear in the original input
|
||||||
return 0;
|
std::sort(v1.begin(), v1.end());
|
||||||
|
if (!std::includes(v0.begin(), v0.end(), v1.begin(), v1.end())) return 4;
|
||||||
|
|
||||||
|
std::sort(v2.begin(), v2.end());
|
||||||
|
if (!std::includes(v0.begin(), v0.end(), v2.begin(), v2.end())) return 5;
|
||||||
|
|
||||||
|
// This, while simple, is really slow - 20 seconds on a 500K element input.
|
||||||
|
// for (auto v: v1)
|
||||||
|
// if (std::find(data, data + size, v) == data + size) return 4;
|
||||||
|
//
|
||||||
|
// for (auto v: v2)
|
||||||
|
// if (std::find(data, data + size, v) == data + size) return 5;
|
||||||
|
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
// == stable_partition ==
|
// == stable_partition ==
|
||||||
int stable_partition (const uint8_t *data, size_t size)
|
int stable_partition (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
StableVec input;
|
StableVec input;
|
||||||
for (size_t i = 0; i < size; ++i)
|
for (size_t i = 0; i < size; ++i)
|
||||||
input.push_back(stable_test(data[i], i));
|
input.push_back(stable_test(data[i], i));
|
||||||
StableVec working = input;
|
StableVec working = input;
|
||||||
auto iter = std::stable_partition(working.begin(), working.end(), is_even<stable_test>());
|
auto iter = std::stable_partition(working.begin(), working.end(), is_even<stable_test>());
|
||||||
|
|
||||||
if (!std::all_of (working.begin(), iter, is_even<stable_test>())) return 1;
|
if (!std::all_of (working.begin(), iter, is_even<stable_test>())) return 1;
|
||||||
if (!std::none_of(iter, working.end(), is_even<stable_test>())) return 2;
|
if (!std::none_of(iter, working.end(), is_even<stable_test>())) return 2;
|
||||||
if (!std::is_sorted(working.begin(), iter, payload_less())) return 3;
|
if (!std::is_sorted(working.begin(), iter, payload_less())) return 3;
|
||||||
if (!std::is_sorted(iter, working.end(), payload_less())) return 4;
|
if (!std::is_sorted(iter, working.end(), payload_less())) return 4;
|
||||||
if (!fuzzing::is_permutation(input.cbegin(), input.cend(), working.cbegin())) return 99;
|
if (!fuzzing::is_permutation(input.cbegin(), input.cend(), working.cbegin())) return 99;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
// == nth_element ==
|
// == nth_element ==
|
||||||
// use the first element as a position into the data
|
// use the first element as a position into the data
|
||||||
int nth_element (const uint8_t *data, size_t size)
|
int nth_element (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
if (size <= 1) return 0;
|
if (size <= 1) return 0;
|
||||||
const size_t partition_point = data[0] % size;
|
const size_t partition_point = data[0] % size;
|
||||||
Vec working(data + 1, data + size);
|
Vec working(data + 1, data + size);
|
||||||
const auto partition_iter = working.begin() + partition_point;
|
const auto partition_iter = working.begin() + partition_point;
|
||||||
std::nth_element(working.begin(), partition_iter, working.end());
|
std::nth_element(working.begin(), partition_iter, working.end());
|
||||||
|
|
||||||
// nth may be the end iterator, in this case nth_element has no effect.
|
// nth may be the end iterator, in this case nth_element has no effect.
|
||||||
if (partition_iter == working.end())
|
if (partition_iter == working.end())
|
||||||
{
|
{
|
||||||
if (!std::equal(data + 1, data + size, working.begin())) return 98;
|
if (!std::equal(data + 1, data + size, working.begin())) return 98;
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
const uint8_t nth = *partition_iter;
|
const uint8_t nth = *partition_iter;
|
||||||
if (!std::all_of(working.begin(), partition_iter, [=](uint8_t v) { return v <= nth; }))
|
if (!std::all_of(working.begin(), partition_iter, [=](uint8_t v) { return v <= nth; }))
|
||||||
return 1;
|
return 1;
|
||||||
if (!std::all_of(partition_iter, working.end(), [=](uint8_t v) { return v >= nth; }))
|
if (!std::all_of(partition_iter, working.end(), [=](uint8_t v) { return v >= nth; }))
|
||||||
return 2;
|
return 2;
|
||||||
if (!fuzzing::is_permutation(data + 1, data + size, working.cbegin())) return 99;
|
if (!fuzzing::is_permutation(data + 1, data + size, working.cbegin())) return 99;
|
||||||
}
|
}
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
// == partial_sort ==
|
// == partial_sort ==
|
||||||
// use the first element as a position into the data
|
// use the first element as a position into the data
|
||||||
int partial_sort (const uint8_t *data, size_t size)
|
int partial_sort (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
if (size <= 1) return 0;
|
if (size <= 1) return 0;
|
||||||
const size_t sort_point = data[0] % size;
|
const size_t sort_point = data[0] % size;
|
||||||
Vec working(data + 1, data + size);
|
Vec working(data + 1, data + size);
|
||||||
const auto sort_iter = working.begin() + sort_point;
|
const auto sort_iter = working.begin() + sort_point;
|
||||||
std::partial_sort(working.begin(), sort_iter, working.end());
|
std::partial_sort(working.begin(), sort_iter, working.end());
|
||||||
|
|
||||||
if (sort_iter != working.end())
|
if (sort_iter != working.end())
|
||||||
{
|
{
|
||||||
const uint8_t nth = *std::min_element(sort_iter, working.end());
|
const uint8_t nth = *std::min_element(sort_iter, working.end());
|
||||||
if (!std::all_of(working.begin(), sort_iter, [=](uint8_t v) { return v <= nth; }))
|
if (!std::all_of(working.begin(), sort_iter, [=](uint8_t v) { return v <= nth; }))
|
||||||
return 1;
|
return 1;
|
||||||
if (!std::all_of(sort_iter, working.end(), [=](uint8_t v) { return v >= nth; }))
|
if (!std::all_of(sort_iter, working.end(), [=](uint8_t v) { return v >= nth; }))
|
||||||
return 2;
|
return 2;
|
||||||
}
|
}
|
||||||
if (!std::is_sorted(working.begin(), sort_iter)) return 3;
|
if (!std::is_sorted(working.begin(), sort_iter)) return 3;
|
||||||
if (!fuzzing::is_permutation(data + 1, data + size, working.cbegin())) return 99;
|
if (!fuzzing::is_permutation(data + 1, data + size, working.cbegin())) return 99;
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
// == partial_sort_copy ==
|
// == partial_sort_copy ==
|
||||||
// use the first element as a count
|
// use the first element as a count
|
||||||
int partial_sort_copy (const uint8_t *data, size_t size)
|
int partial_sort_copy (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
if (size <= 1) return 0;
|
if (size <= 1) return 0;
|
||||||
const size_t num_results = data[0] % size;
|
const size_t num_results = data[0] % size;
|
||||||
Vec results(num_results);
|
Vec results(num_results);
|
||||||
(void) std::partial_sort_copy(data + 1, data + size, results.begin(), results.end());
|
(void) std::partial_sort_copy(data + 1, data + size, results.begin(), results.end());
|
||||||
|
|
||||||
// The results have to be sorted
|
// The results have to be sorted
|
||||||
if (!std::is_sorted(results.begin(), results.end())) return 1;
|
if (!std::is_sorted(results.begin(), results.end())) return 1;
|
||||||
// All the values in results have to be in the original data
|
// All the values in results have to be in the original data
|
||||||
for (auto v: results)
|
for (auto v: results)
|
||||||
if (std::find(data + 1, data + size, v) == data + size) return 2;
|
if (std::find(data + 1, data + size, v) == data + size) return 2;
|
||||||
|
|
||||||
// The things in results have to be the smallest N in the original data
|
// The things in results have to be the smallest N in the original data
|
||||||
Vec sorted(data + 1, data + size);
|
Vec sorted(data + 1, data + size);
|
||||||
std::sort(sorted.begin(), sorted.end());
|
std::sort(sorted.begin(), sorted.end());
|
||||||
if (!std::equal(results.begin(), results.end(), sorted.begin())) return 3;
|
if (!std::equal(results.begin(), results.end(), sorted.begin())) return 3;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
// The second sequence has been "uniqued"
|
// The second sequence has been "uniqued"
|
||||||
template <typename Iter1, typename Iter2>
|
template <typename Iter1, typename Iter2>
|
||||||
static bool compare_unique(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2)
|
static bool compare_unique(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2)
|
||||||
{
|
{
|
||||||
assert(first1 != last1 && first2 != last2);
|
assert(first1 != last1 && first2 != last2);
|
||||||
if (*first1 != *first2) return false;
|
if (*first1 != *first2) return false;
|
||||||
|
|
||||||
uint8_t last_value = *first1;
|
uint8_t last_value = *first1;
|
||||||
++first1; ++first2;
|
++first1; ++first2;
|
||||||
while(first1 != last1 && first2 != last2)
|
while(first1 != last1 && first2 != last2)
|
||||||
{
|
{
|
||||||
// Skip over dups in the first sequence
|
// Skip over dups in the first sequence
|
||||||
while (*first1 == last_value)
|
while (*first1 == last_value)
|
||||||
if (++first1 == last1) return false;
|
if (++first1 == last1) return false;
|
||||||
if (*first1 != *first2) return false;
|
if (*first1 != *first2) return false;
|
||||||
last_value = *first1;
|
last_value = *first1;
|
||||||
++first1; ++first2;
|
++first1; ++first2;
|
||||||
}
|
}
|
||||||
|
|
||||||
// Still stuff left in the 'uniqued' sequence - oops
|
// Still stuff left in the 'uniqued' sequence - oops
|
||||||
if (first1 == last1 && first2 != last2) return false;
|
if (first1 == last1 && first2 != last2) return false;
|
||||||
|
|
||||||
// Still stuff left in the original sequence - better be all the same
|
// Still stuff left in the original sequence - better be all the same
|
||||||
while (first1 != last1)
|
while (first1 != last1)
|
||||||
{
|
{
|
||||||
if (*first1 != last_value) return false;
|
if (*first1 != last_value) return false;
|
||||||
++first1;
|
++first1;
|
||||||
}
|
}
|
||||||
return true;
|
return true;
|
||||||
}
|
}
|
||||||
|
|
||||||
// == unique ==
|
// == unique ==
|
||||||
int unique (const uint8_t *data, size_t size)
|
int unique (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
Vec working(data, data + size);
|
Vec working(data, data + size);
|
||||||
std::sort(working.begin(), working.end());
|
std::sort(working.begin(), working.end());
|
||||||
Vec results = working;
|
Vec results = working;
|
||||||
Vec::iterator new_end = std::unique(results.begin(), results.end());
|
Vec::iterator new_end = std::unique(results.begin(), results.end());
|
||||||
Vec::iterator it; // scratch iterator
|
Vec::iterator it; // scratch iterator
|
||||||
|
|
||||||
// Check the size of the unique'd sequence.
|
|
||||||
// it should only be zero if the input sequence was empty.
|
|
||||||
if (results.begin() == new_end)
|
|
||||||
return working.size() == 0 ? 0 : 1;
|
|
||||||
|
|
||||||
// 'results' is sorted
|
|
||||||
if (!std::is_sorted(results.begin(), new_end)) return 2;
|
|
||||||
|
|
||||||
// All the elements in 'results' must be different
|
// Check the size of the unique'd sequence.
|
||||||
it = results.begin();
|
// it should only be zero if the input sequence was empty.
|
||||||
uint8_t prev_value = *it++;
|
if (results.begin() == new_end)
|
||||||
for (; it != new_end; ++it)
|
return working.size() == 0 ? 0 : 1;
|
||||||
{
|
|
||||||
if (*it == prev_value) return 3;
|
// 'results' is sorted
|
||||||
prev_value = *it;
|
if (!std::is_sorted(results.begin(), new_end)) return 2;
|
||||||
}
|
|
||||||
|
// All the elements in 'results' must be different
|
||||||
// Every element in 'results' must be in 'working'
|
it = results.begin();
|
||||||
for (it = results.begin(); it != new_end; ++it)
|
uint8_t prev_value = *it++;
|
||||||
if (std::find(working.begin(), working.end(), *it) == working.end())
|
for (; it != new_end; ++it)
|
||||||
return 4;
|
{
|
||||||
|
if (*it == prev_value) return 3;
|
||||||
// Every element in 'working' must be in 'results'
|
prev_value = *it;
|
||||||
for (auto v : working)
|
}
|
||||||
if (std::find(results.begin(), new_end, v) == new_end)
|
|
||||||
return 5;
|
// Every element in 'results' must be in 'working'
|
||||||
|
for (it = results.begin(); it != new_end; ++it)
|
||||||
return 0;
|
if (std::find(working.begin(), working.end(), *it) == working.end())
|
||||||
|
return 4;
|
||||||
|
|
||||||
|
// Every element in 'working' must be in 'results'
|
||||||
|
for (auto v : working)
|
||||||
|
if (std::find(results.begin(), new_end, v) == new_end)
|
||||||
|
return 5;
|
||||||
|
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
// == unique_copy ==
|
// == unique_copy ==
|
||||||
int unique_copy (const uint8_t *data, size_t size)
|
int unique_copy (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
Vec working(data, data + size);
|
Vec working(data, data + size);
|
||||||
std::sort(working.begin(), working.end());
|
std::sort(working.begin(), working.end());
|
||||||
Vec results;
|
Vec results;
|
||||||
(void) std::unique_copy(working.begin(), working.end(),
|
(void) std::unique_copy(working.begin(), working.end(),
|
||||||
std::back_inserter<Vec>(results));
|
std::back_inserter<Vec>(results));
|
||||||
Vec::iterator it; // scratch iterator
|
Vec::iterator it; // scratch iterator
|
||||||
|
|
||||||
// Check the size of the unique'd sequence.
|
|
||||||
// it should only be zero if the input sequence was empty.
|
|
||||||
if (results.size() == 0)
|
|
||||||
return working.size() == 0 ? 0 : 1;
|
|
||||||
|
|
||||||
// 'results' is sorted
|
|
||||||
if (!std::is_sorted(results.begin(), results.end())) return 2;
|
|
||||||
|
|
||||||
// All the elements in 'results' must be different
|
// Check the size of the unique'd sequence.
|
||||||
it = results.begin();
|
// it should only be zero if the input sequence was empty.
|
||||||
uint8_t prev_value = *it++;
|
if (results.size() == 0)
|
||||||
for (; it != results.end(); ++it)
|
return working.size() == 0 ? 0 : 1;
|
||||||
{
|
|
||||||
if (*it == prev_value) return 3;
|
// 'results' is sorted
|
||||||
prev_value = *it;
|
if (!std::is_sorted(results.begin(), results.end())) return 2;
|
||||||
}
|
|
||||||
|
// All the elements in 'results' must be different
|
||||||
// Every element in 'results' must be in 'working'
|
it = results.begin();
|
||||||
for (auto v : results)
|
uint8_t prev_value = *it++;
|
||||||
if (std::find(working.begin(), working.end(), v) == working.end())
|
for (; it != results.end(); ++it)
|
||||||
return 4;
|
{
|
||||||
|
if (*it == prev_value) return 3;
|
||||||
// Every element in 'working' must be in 'results'
|
prev_value = *it;
|
||||||
for (auto v : working)
|
}
|
||||||
if (std::find(results.begin(), results.end(), v) == results.end())
|
|
||||||
return 5;
|
// Every element in 'results' must be in 'working'
|
||||||
|
for (auto v : results)
|
||||||
return 0;
|
if (std::find(working.begin(), working.end(), v) == working.end())
|
||||||
|
return 4;
|
||||||
|
|
||||||
|
// Every element in 'working' must be in 'results'
|
||||||
|
for (auto v : working)
|
||||||
|
if (std::find(results.begin(), results.end(), v) == results.end())
|
||||||
|
return 5;
|
||||||
|
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
// -- regex fuzzers
|
// -- regex fuzzers
|
||||||
static int regex_helper(const uint8_t *data, size_t size, std::regex::flag_type flag)
|
static int regex_helper(const uint8_t *data, size_t size, std::regex::flag_type flag)
|
||||||
{
|
{
|
||||||
if (size > 0)
|
if (size > 0)
|
||||||
{
|
{
|
||||||
try
|
try
|
||||||
{
|
{
|
||||||
std::string s((const char *)data, size);
|
std::string s((const char *)data, size);
|
||||||
std::regex re(s, flag);
|
std::regex re(s, flag);
|
||||||
return std::regex_match(s, re) ? 1 : 0;
|
return std::regex_match(s, re) ? 1 : 0;
|
||||||
}
|
}
|
||||||
catch (std::regex_error &ex) {}
|
catch (std::regex_error &ex) {}
|
||||||
}
|
}
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
int regex_ECMAScript (const uint8_t *data, size_t size)
|
int regex_ECMAScript (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
(void) regex_helper(data, size, std::regex_constants::ECMAScript);
|
(void) regex_helper(data, size, std::regex_constants::ECMAScript);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int regex_POSIX (const uint8_t *data, size_t size)
|
int regex_POSIX (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
(void) regex_helper(data, size, std::regex_constants::basic);
|
(void) regex_helper(data, size, std::regex_constants::basic);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int regex_extended (const uint8_t *data, size_t size)
|
int regex_extended (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
(void) regex_helper(data, size, std::regex_constants::extended);
|
(void) regex_helper(data, size, std::regex_constants::extended);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int regex_awk (const uint8_t *data, size_t size)
|
int regex_awk (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
(void) regex_helper(data, size, std::regex_constants::awk);
|
(void) regex_helper(data, size, std::regex_constants::awk);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int regex_grep (const uint8_t *data, size_t size)
|
int regex_grep (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
(void) regex_helper(data, size, std::regex_constants::grep);
|
(void) regex_helper(data, size, std::regex_constants::grep);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int regex_egrep (const uint8_t *data, size_t size)
|
int regex_egrep (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
(void) regex_helper(data, size, std::regex_constants::egrep);
|
(void) regex_helper(data, size, std::regex_constants::egrep);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
// -- heap fuzzers
|
// -- heap fuzzers
|
||||||
int make_heap (const uint8_t *data, size_t size)
|
int make_heap (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
Vec working(data, data + size);
|
Vec working(data, data + size);
|
||||||
std::make_heap(working.begin(), working.end());
|
std::make_heap(working.begin(), working.end());
|
||||||
|
|
||||||
if (!std::is_heap(working.begin(), working.end())) return 1;
|
if (!std::is_heap(working.begin(), working.end())) return 1;
|
||||||
if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
|
if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int push_heap (const uint8_t *data, size_t size)
|
int push_heap (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
if (size < 2) return 0;
|
if (size < 2) return 0;
|
||||||
|
|
||||||
// Make a heap from the first half of the data
|
// Make a heap from the first half of the data
|
||||||
Vec working(data, data + size);
|
Vec working(data, data + size);
|
||||||
auto iter = working.begin() + (size / 2);
|
auto iter = working.begin() + (size / 2);
|
||||||
std::make_heap(working.begin(), iter);
|
std::make_heap(working.begin(), iter);
|
||||||
if (!std::is_heap(working.begin(), iter)) return 1;
|
if (!std::is_heap(working.begin(), iter)) return 1;
|
||||||
|
|
||||||
// Now push the rest onto the heap, one at a time
|
// Now push the rest onto the heap, one at a time
|
||||||
++iter;
|
++iter;
|
||||||
for (; iter != working.end(); ++iter) {
|
for (; iter != working.end(); ++iter) {
|
||||||
std::push_heap(working.begin(), iter);
|
std::push_heap(working.begin(), iter);
|
||||||
if (!std::is_heap(working.begin(), iter)) return 2;
|
if (!std::is_heap(working.begin(), iter)) return 2;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
|
if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
int pop_heap (const uint8_t *data, size_t size)
|
int pop_heap (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
if (size < 2) return 0;
|
if (size < 2) return 0;
|
||||||
Vec working(data, data + size);
|
Vec working(data, data + size);
|
||||||
std::make_heap(working.begin(), working.end());
|
std::make_heap(working.begin(), working.end());
|
||||||
|
|
||||||
// Pop things off, one at a time
|
// Pop things off, one at a time
|
||||||
auto iter = --working.end();
|
auto iter = --working.end();
|
||||||
while (iter != working.begin()) {
|
while (iter != working.begin()) {
|
||||||
std::pop_heap(working.begin(), iter);
|
std::pop_heap(working.begin(), iter);
|
||||||
if (!std::is_heap(working.begin(), --iter)) return 2;
|
if (!std::is_heap(working.begin(), --iter)) return 2;
|
||||||
}
|
}
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
// -- search fuzzers
|
// -- search fuzzers
|
||||||
int search (const uint8_t *data, size_t size)
|
int search (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
if (size < 2) return 0;
|
if (size < 2) return 0;
|
||||||
|
|
||||||
const size_t pat_size = data[0] * (size - 1) / std::numeric_limits<uint8_t>::max();
|
const size_t pat_size = data[0] * (size - 1) / std::numeric_limits<uint8_t>::max();
|
||||||
assert(pat_size <= size - 1);
|
assert(pat_size <= size - 1);
|
||||||
const uint8_t *pat_begin = data + 1;
|
const uint8_t *pat_begin = data + 1;
|
||||||
const uint8_t *pat_end = pat_begin + pat_size;
|
const uint8_t *pat_end = pat_begin + pat_size;
|
||||||
const uint8_t *data_end = data + size;
|
const uint8_t *data_end = data + size;
|
||||||
assert(pat_end <= data_end);
|
assert(pat_end <= data_end);
|
||||||
// std::cerr << "data[0] = " << size_t(data[0]) << " ";
|
// std::cerr << "data[0] = " << size_t(data[0]) << " ";
|
||||||
// std::cerr << "Pattern size = " << pat_size << "; corpus is " << size - 1 << std::endl;
|
// std::cerr << "Pattern size = " << pat_size << "; corpus is " << size - 1 << std::endl;
|
||||||
auto it = std::search(pat_end, data_end, pat_begin, pat_end);
|
auto it = std::search(pat_end, data_end, pat_begin, pat_end);
|
||||||
if (it != data_end) // not found
|
if (it != data_end) // not found
|
||||||
if (!std::equal(pat_begin, pat_end, it))
|
if (!std::equal(pat_begin, pat_end, it))
|
||||||
return 1;
|
return 1;
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
template <typename S>
|
template <typename S>
|
||||||
static int search_helper (const uint8_t *data, size_t size)
|
static int search_helper (const uint8_t *data, size_t size)
|
||||||
{
|
{
|
||||||
if (size < 2) return 0;
|
if (size < 2) return 0;
|
||||||
|
|
||||||
const size_t pat_size = data[0] * (size - 1) / std::numeric_limits<uint8_t>::max();
|
|
||||||
const uint8_t *pat_begin = data + 1;
|
|
||||||
const uint8_t *pat_end = pat_begin + pat_size;
|
|
||||||
const uint8_t *data_end = data + size;
|
|
||||||
|
|
||||||
auto it = std::search(pat_end, data_end, S(pat_begin, pat_end));
|
const size_t pat_size = data[0] * (size - 1) / std::numeric_limits<uint8_t>::max();
|
||||||
if (it != data_end) // not found
|
const uint8_t *pat_begin = data + 1;
|
||||||
if (!std::equal(pat_begin, pat_end, it))
|
const uint8_t *pat_end = pat_begin + pat_size;
|
||||||
return 1;
|
const uint8_t *data_end = data + size;
|
||||||
return 0;
|
|
||||||
|
auto it = std::search(pat_end, data_end, S(pat_begin, pat_end));
|
||||||
|
if (it != data_end) // not found
|
||||||
|
if (!std::equal(pat_begin, pat_end, it))
|
||||||
|
return 1;
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
// These are still in std::experimental
|
// These are still in std::experimental
|
||||||
// int search_boyer_moore (const uint8_t *data, size_t size)
|
// int search_boyer_moore (const uint8_t *data, size_t size)
|
||||||
// {
|
// {
|
||||||
// return search_helper<std::boyer_moore_searcher<const uint8_t *>>(data, size);
|
// return search_helper<std::boyer_moore_searcher<const uint8_t *>>(data, size);
|
||||||
// }
|
// }
|
||||||
//
|
//
|
||||||
// int search_boyer_moore_horspool (const uint8_t *data, size_t size)
|
// int search_boyer_moore_horspool (const uint8_t *data, size_t size)
|
||||||
// {
|
// {
|
||||||
// return search_helper<std::boyer_moore_horspool_searcher<const uint8_t *>>(data, size);
|
// return search_helper<std::boyer_moore_horspool_searcher<const uint8_t *>>(data, size);
|
||||||
// }
|
// }
|
||||||
|
|
||||||
|
|
||||||
// -- set operation fuzzers
|
// -- set operation fuzzers
|
||||||
template <typename S>
|
template <typename S>
|
||||||
static void set_helper (const uint8_t *data, size_t size, Vec &v1, Vec &v2)
|
static void set_helper (const uint8_t *data, size_t size, Vec &v1, Vec &v2)
|
||||||
{
|
{
|
||||||
assert(size > 1);
|
assert(size > 1);
|
||||||
|
|
||||||
const size_t pat_size = data[0] * (size - 1) / std::numeric_limits<uint8_t>::max();
|
|
||||||
const uint8_t *pat_begin = data + 1;
|
|
||||||
const uint8_t *pat_end = pat_begin + pat_size;
|
|
||||||
const uint8_t *data_end = data + size;
|
|
||||||
v1.assign(pat_begin, pat_end);
|
|
||||||
v2.assign(pat_end, data_end);
|
|
||||||
|
|
||||||
std::sort(v1.begin(), v1.end());
|
const size_t pat_size = data[0] * (size - 1) / std::numeric_limits<uint8_t>::max();
|
||||||
std::sort(v2.begin(), v2.end());
|
const uint8_t *pat_begin = data + 1;
|
||||||
|
const uint8_t *pat_end = pat_begin + pat_size;
|
||||||
|
const uint8_t *data_end = data + size;
|
||||||
|
v1.assign(pat_begin, pat_end);
|
||||||
|
v2.assign(pat_end, data_end);
|
||||||
|
|
||||||
|
std::sort(v1.begin(), v1.end());
|
||||||
|
std::sort(v2.begin(), v2.end());
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace fuzzing
|
} // namespace fuzzing
|
||||||
|
|||||||
Reference in New Issue
Block a user