Vendor import of libc++ trunk r351319 (just before the release_80vendor/libc++/libc++-trunk-r351319

branch point):
https://llvm.org/svn/llvm-project/libcxx/trunk@351319

1 files changed, 421 insertions, 408 deletions

diff --git a/fuzzing/fuzzing.cpp b/fuzzing/fuzzing.cpp
index 8888cbeac72e..ad377bcac467 100644
--- a/fuzzing/fuzzing.cpp
+++ b/fuzzing/fuzzing.cpp
@@ -8,18 +8,18 @@
 //
 //===----------------------------------------------------------------------===//
 
-//	A set of routines to use when fuzzing the algorithms in libc++
-//	Each one tests a single algorithm.
+//  A set of routines to use when fuzzing the algorithms in libc++
+//  Each one tests a single algorithm.
 //
-//	They all have the form of:
-//		int `algorithm`(const uint8_t *data, size_t size);
+//  They all have the form of:
+//      int `algorithm`(const uint8_t *data, size_t size);
 //
-//	They perform the operation, and then check to see if the results are correct.
-//	If so, they return zero, and non-zero otherwise.
+//  They perform the operation, and then check to see if the results are correct.
+//  If so, they return zero, and non-zero otherwise.
 //
-//	For example, sort calls std::sort, then checks two things:
-//		(1) The resulting vector is sorted
-//		(2) The resulting vector contains the same elements as the original data.
+//  For example, sort calls std::sort, then checks two things:
+//      (1) The resulting vector is sorted
+//      (2) The resulting vector contains the same elements as the original data.
 
 
 
@@ -32,574 +32,587 @@
 
 #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 {
 
-//	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.
+//  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.
 
 struct stable_test {
-	uint8_t key;
-	size_t payload;
-	
-	stable_test(uint8_t k) : key(k), payload(0) {}
-	stable_test(uint8_t k, size_t p) : key(k), payload(p) {}
-	};
+    uint8_t key;
+    size_t payload;
+
+    stable_test(uint8_t k) : key(k), payload(0) {}
+    stable_test(uint8_t k, size_t p) : key(k), payload(p) {}
+    };
 
 void swap(stable_test &lhs, stable_test &rhs)
 {
-	using std::swap;
-	swap(lhs.key,     rhs.key);
-	swap(lhs.payload, rhs.payload);
+    using std::swap;
+    swap(lhs.key,     rhs.key);
+    swap(lhs.payload, rhs.payload);
 }
 
 struct key_less
 {
-	bool operator () (const stable_test &lhs, const stable_test &rhs) const
-	{
-		return lhs.key < rhs.key;
-	}
+    bool operator () (const stable_test &lhs, const stable_test &rhs) const
+    {
+        return lhs.key < rhs.key;
+    }
 };
 
 struct payload_less
 {
-	bool operator () (const stable_test &lhs, const stable_test &rhs) const
-	{
-		return lhs.payload < rhs.payload;
-	}
+    bool operator () (const stable_test &lhs, const stable_test &rhs) const
+    {
+        return lhs.payload < rhs.payload;
+    }
 };
 
 struct total_less
 {
-	bool operator () (const stable_test &lhs, const stable_test &rhs) const
-	{
-		return lhs.key == rhs.key ? lhs.payload < rhs.payload : lhs.key < rhs.key;
-	}
+    bool operator () (const stable_test &lhs, const stable_test &rhs) const
+    {
+        return lhs.key == rhs.key ? lhs.payload < rhs.payload : lhs.key < rhs.key;
+    }
 };
 
 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>
 struct is_even
 {
-	bool operator () (const T &t) const
-	{
-		return t % 2 == 0;
-	}
+    bool operator () (const T &t) const
+    {
+        return t % 2 == 0;
+    }
 };
 
 
 template<>
 struct is_even<stable_test>
 {
-	bool operator () (const stable_test &t) const
-	{
-		return t.key % 2 == 0;
-	}
+    bool operator () (const stable_test &t) const
+    {
+        return t.key % 2 == 0;
+    }
 };
 
 typedef std::vector<uint8_t> Vec;
 typedef std::vector<stable_test> StableVec;
 typedef StableVec::const_iterator SVIter;
 
-//	Cheap version of is_permutation
-//	Builds a set of buckets for each of the key values.
-//	Sums all the payloads.
-//	Not 100% perfect, but _way_ faster
+//  Cheap version of is_permutation
+//  Builds a set of buckets for each of the key values.
+//  Sums all the payloads.
+//  Not 100% perfect, but _way_ faster
 bool is_permutation(SVIter first1, SVIter last1, SVIter first2)
 {
-	size_t xBuckets[256]  = {0};
-	size_t xPayloads[256] = {0};
-	size_t yBuckets[256]  = {0};
-	size_t yPayloads[256] = {0};
-	
-	for (; first1 != last1; ++first1, ++first2)
-	{
-		xBuckets [first1->key]++;
-		xPayloads[first1->key] += first1->payload;
-
-		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;
+    size_t xBuckets[256]  = {0};
+    size_t xPayloads[256] = {0};
+    size_t yBuckets[256]  = {0};
+    size_t yPayloads[256] = {0};
+
+    for (; first1 != last1; ++first1, ++first2)
+    {
+        xBuckets [first1->key]++;
+        xPayloads[first1->key] += first1->payload;
+
+        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>
 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<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;
+    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), "");
+
+    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)
 {
-	Vec working(data, data + size);
-	std::sort(working.begin(), working.end());
+    Vec working(data, data + size);
+    std::sort(working.begin(), working.end());
 
-	if (!std::is_sorted(working.begin(), working.end())) return 1;
-	if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
-	return 0;
+    if (!std::is_sorted(working.begin(), working.end())) return 1;
+    if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
+    return 0;
 }
 
 
-//	== stable_sort ==
+//  == stable_sort ==
 int stable_sort(const uint8_t *data, size_t size)
 {
-	StableVec input;
-	for (size_t i = 0; i < size; ++i)
-		input.push_back(stable_test(data[i], i));
-	StableVec working = input;
-	std::stable_sort(working.begin(), working.end(), key_less());
-
-	if (!std::is_sorted(working.begin(), working.end(), key_less()))   return 1;
-	auto iter = working.begin();
-	while (iter != working.end())
-	{
-		auto range = std::equal_range(iter, working.end(), *iter, key_less());
-		if (!std::is_sorted(range.first, range.second, total_less())) return 2;			
-		iter = range.second;
-	}
-	if (!fuzzing::is_permutation(input.cbegin(), input.cend(), working.cbegin())) return 99;
-	return 0;
+    StableVec input;
+    for (size_t i = 0; i < size; ++i)
+        input.push_back(stable_test(data[i], i));
+    StableVec working = input;
+    std::stable_sort(working.begin(), working.end(), key_less());
+
+    if (!std::is_sorted(working.begin(), working.end(), key_less()))   return 1;
+    auto iter = working.begin();
+    while (iter != working.end())
+    {
+        auto range = std::equal_range(iter, working.end(), *iter, key_less());
+        if (!std::is_sorted(range.first, range.second, total_less())) return 2;
+        iter = range.second;
+    }
+    if (!fuzzing::is_permutation(input.cbegin(), input.cend(), working.cbegin())) return 99;
+    return 0;
 }
 
-//	== partition ==
+//  == partition ==
 int partition(const uint8_t *data, size_t size)
 {
-	Vec working(data, data + size);
-	auto iter = std::partition(working.begin(), working.end(), is_even<uint8_t>());
+    Vec working(data, data + size);
+    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::none_of(iter,   working.end(), is_even<uint8_t>())) return 2;
-	if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
-	return 0;
+    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 (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
+    return 0;
 }
 
 
-//	== partition_copy ==
+//  == partition_copy ==
 int partition_copy(const uint8_t *data, size_t size)
 {
-	Vec v1, v2;
-	auto iter = std::partition_copy(data, data + size,
-		std::back_inserter<Vec>(v1), std::back_inserter<Vec>(v2),
-		is_even<uint8_t>());
-
-//	The two vectors should add up to the original size
-	if (v1.size() + v2.size() != size) return 1;
-
-//	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::none_of(v2.begin(), v2.end(), is_even<uint8_t>())) return 3;
-
-//	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;
-			
-	for (auto v: v2)
-		if (std::find(data, data + size, v) == data + size) return 5;
-			
-	return 0;
+    Vec v1, v2;
+    auto iter = std::partition_copy(data, data + size,
+        std::back_inserter<Vec>(v1), std::back_inserter<Vec>(v2),
+        is_even<uint8_t>());
+
+//  The two vectors should add up to the original size
+    if (v1.size() + v2.size() != size) return 1;
+
+//  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::none_of(v2.begin(), v2.end(), is_even<uint8_t>())) return 3;
+
+//  Every value in both vectors has to be in the original
+
+//	Make a copy of the input, and sort it
+    Vec v0{data, data + size};
+    std::sort(v0.begin(), v0.end());
+
+//	Sort each vector and ensure that all of the elements appear in the original input
+    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)
 {
-	StableVec input;
-	for (size_t i = 0; i < size; ++i)
-		input.push_back(stable_test(data[i], i));
-	StableVec working = input;
-	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::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(iter,   working.end(), payload_less()))   return 4;
-	if (!fuzzing::is_permutation(input.cbegin(), input.cend(), working.cbegin())) return 99;
-	return 0;
+    StableVec input;
+    for (size_t i = 0; i < size; ++i)
+        input.push_back(stable_test(data[i], i));
+    StableVec working = input;
+    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::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(iter,   working.end(), payload_less()))   return 4;
+    if (!fuzzing::is_permutation(input.cbegin(), input.cend(), working.cbegin())) return 99;
+    return 0;
 }
 
-//	== nth_element ==
-//	use the first element as a position into the data
+//  == nth_element ==
+//  use the first element as a position into the data
 int nth_element (const uint8_t *data, size_t size)
 {
-	if (size <= 1) return 0;
-	const size_t partition_point = data[0] % size;	
-	Vec working(data + 1, data + size);
-	const auto partition_iter = working.begin() + partition_point;
-	std::nth_element(working.begin(), partition_iter, working.end());
-
-//	nth may be the end iterator, in this case nth_element has no effect.
-	if (partition_iter == working.end())
-	{
-		if (!std::equal(data + 1, data + size, working.begin())) return 98;
-	}
-	else
-	{
-		const uint8_t nth = *partition_iter;
-		if (!std::all_of(working.begin(), partition_iter, [=](uint8_t v) { return v <= nth; }))
-			return 1;
-		if (!std::all_of(partition_iter, working.end(),   [=](uint8_t v) { return v >= nth; }))
-			return 2;
-		if (!fuzzing::is_permutation(data + 1, data + size, working.cbegin())) return 99;
-		}
-
-	return 0;
+    if (size <= 1) return 0;
+    const size_t partition_point = data[0] % size;
+    Vec working(data + 1, data + size);
+    const auto partition_iter = working.begin() + partition_point;
+    std::nth_element(working.begin(), partition_iter, working.end());
+
+//  nth may be the end iterator, in this case nth_element has no effect.
+    if (partition_iter == working.end())
+    {
+        if (!std::equal(data + 1, data + size, working.begin())) return 98;
+    }
+    else
+    {
+        const uint8_t nth = *partition_iter;
+        if (!std::all_of(working.begin(), partition_iter, [=](uint8_t v) { return v <= nth; }))
+            return 1;
+        if (!std::all_of(partition_iter, working.end(),   [=](uint8_t v) { return v >= nth; }))
+            return 2;
+        if (!fuzzing::is_permutation(data + 1, data + size, working.cbegin())) return 99;
+        }
+
+    return 0;
 }
 
-//	== partial_sort ==
-//	use the first element as a position into the data
+//  == partial_sort ==
+//  use the first element as a position into the data
 int partial_sort (const uint8_t *data, size_t size)
 {
-	if (size <= 1) return 0;
-	const size_t sort_point = data[0] % size;
-	Vec working(data + 1, data + size);
-	const auto sort_iter = working.begin() + sort_point;
-	std::partial_sort(working.begin(), sort_iter, working.end());
-
-	if (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; }))
-			return 1;
-		if (!std::all_of(sort_iter, working.end(),   [=](uint8_t v) { return v >= nth; }))
-			return 2;		
-	}
-	if (!std::is_sorted(working.begin(), sort_iter)) return 3;
-	if (!fuzzing::is_permutation(data + 1, data + size, working.cbegin())) return 99;
-
-	return 0;
+    if (size <= 1) return 0;
+    const size_t sort_point = data[0] % size;
+    Vec working(data + 1, data + size);
+    const auto sort_iter = working.begin() + sort_point;
+    std::partial_sort(working.begin(), sort_iter, working.end());
+
+    if (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; }))
+            return 1;
+        if (!std::all_of(sort_iter, working.end(),   [=](uint8_t v) { return v >= nth; }))
+            return 2;
+    }
+    if (!std::is_sorted(working.begin(), sort_iter)) return 3;
+    if (!fuzzing::is_permutation(data + 1, data + size, working.cbegin())) return 99;
+
+    return 0;
 }
 
 
-//	== partial_sort_copy ==
-//	use the first element as a count
+//  == partial_sort_copy ==
+//  use the first element as a count
 int partial_sort_copy (const uint8_t *data, size_t size)
 {
-	if (size <= 1) return 0;
-	const size_t num_results = data[0] % size;
-	Vec results(num_results);
-	(void) std::partial_sort_copy(data + 1, data + size, results.begin(), results.end());
-
-//	The results have to be sorted
-	if (!std::is_sorted(results.begin(), results.end())) return 1;
-//	All the values in results have to be in the original data
-	for (auto v: results)
-		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
-	Vec sorted(data + 1, data + size);
-	std::sort(sorted.begin(), sorted.end());
-	if (!std::equal(results.begin(), results.end(), sorted.begin())) return 3;
-	return 0;
+    if (size <= 1) return 0;
+    const size_t num_results = data[0] % size;
+    Vec results(num_results);
+    (void) std::partial_sort_copy(data + 1, data + size, results.begin(), results.end());
+
+//  The results have to be sorted
+    if (!std::is_sorted(results.begin(), results.end())) return 1;
+//  All the values in results have to be in the original data
+    for (auto v: results)
+        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
+    Vec sorted(data + 1, data + size);
+    std::sort(sorted.begin(), sorted.end());
+    if (!std::equal(results.begin(), results.end(), sorted.begin())) return 3;
+    return 0;
 }
 
-//	The second sequence has been "uniqued"
+//  The second sequence has been "uniqued"
 template <typename Iter1, typename Iter2>
 static bool compare_unique(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2)
 {
-	assert(first1 != last1 && first2 != last2);
-	if (*first1 != *first2) return false;
-
-	uint8_t last_value = *first1;
-	++first1; ++first2;
-	while(first1 != last1 && first2 != last2)
-	{
-	//	Skip over dups in the first sequence
-		while (*first1 == last_value)
-			if (++first1 == last1) return false;
-		if (*first1 != *first2) return false;
-		last_value = *first1;
-		++first1; ++first2;
-	}
-
-//	Still stuff left in the 'uniqued' sequence - oops
-	if (first1 == last1 && first2 != last2) return false;
-
-//	Still stuff left in the original sequence - better be all the same
-	while (first1 != last1)
-	{
-		if (*first1 != last_value) return false;
-		++first1;
-	}
-	return true;
+    assert(first1 != last1 && first2 != last2);
+    if (*first1 != *first2) return false;
+
+    uint8_t last_value = *first1;
+    ++first1; ++first2;
+    while(first1 != last1 && first2 != last2)
+    {
+    //  Skip over dups in the first sequence
+        while (*first1 == last_value)
+            if (++first1 == last1) return false;
+        if (*first1 != *first2) return false;
+        last_value = *first1;
+        ++first1; ++first2;
+    }
+
+//  Still stuff left in the 'uniqued' sequence - oops
+    if (first1 == last1 && first2 != last2) return false;
+
+//  Still stuff left in the original sequence - better be all the same
+    while (first1 != last1)
+    {
+        if (*first1 != last_value) return false;
+        ++first1;
+    }
+    return true;
 }
 
-//	== unique ==
+//  == unique ==
 int unique (const uint8_t *data, size_t size)
 {
-	Vec working(data, data + size);
-	std::sort(working.begin(), working.end());
-	Vec results = working;
-	Vec::iterator new_end = std::unique(results.begin(), results.end());
-	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
-	it = results.begin();
-	uint8_t prev_value = *it++;
-	for (; it != new_end; ++it)
-	{
-		if (*it == prev_value) return 3;
-		prev_value = *it;
-	}
-	
-//	Every element in 'results' must be in 'working'
-	for (it = results.begin(); it != new_end; ++it)
-		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;
+    Vec working(data, data + size);
+    std::sort(working.begin(), working.end());
+    Vec results = working;
+    Vec::iterator new_end = std::unique(results.begin(), results.end());
+    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
+    it = results.begin();
+    uint8_t prev_value = *it++;
+    for (; it != new_end; ++it)
+    {
+        if (*it == prev_value) return 3;
+        prev_value = *it;
+    }
+
+//  Every element in 'results' must be in 'working'
+    for (it = results.begin(); it != new_end; ++it)
+        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)
 {
-	Vec working(data, data + size);
-	std::sort(working.begin(), working.end());
-	Vec results;
-	(void) std::unique_copy(working.begin(), working.end(),
-	                        std::back_inserter<Vec>(results));
-	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
-	it = results.begin();
-	uint8_t prev_value = *it++;
-	for (; it != results.end(); ++it)
-	{
-		if (*it == prev_value) return 3;
-		prev_value = *it;
-	}
-	
-//	Every element in 'results' must be in 'working'
-	for (auto v : results)
-		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;
+    Vec working(data, data + size);
+    std::sort(working.begin(), working.end());
+    Vec results;
+    (void) std::unique_copy(working.begin(), working.end(),
+                            std::back_inserter<Vec>(results));
+    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
+    it = results.begin();
+    uint8_t prev_value = *it++;
+    for (; it != results.end(); ++it)
+    {
+        if (*it == prev_value) return 3;
+        prev_value = *it;
+    }
+
+//  Every element in 'results' must be in 'working'
+    for (auto v : results)
+        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)
 {
-	if (size > 0)
-	{
-		try
-		{
-			std::string s((const char *)data, size);
-			std::regex re(s, flag);
-			return std::regex_match(s, re) ? 1 : 0;
-		} 
-		catch (std::regex_error &ex) {} 
-	}
-	return 0;		
+    if (size > 0)
+    {
+        try
+        {
+            std::string s((const char *)data, size);
+            std::regex re(s, flag);
+            return std::regex_match(s, re) ? 1 : 0;
+        }
+        catch (std::regex_error &ex) {}
+    }
+    return 0;
 }
 
 
 int regex_ECMAScript (const uint8_t *data, size_t size)
 {
-	(void) regex_helper(data, size, std::regex_constants::ECMAScript);
-	return 0;
+    (void) regex_helper(data, size, std::regex_constants::ECMAScript);
+    return 0;
 }
 
 int regex_POSIX (const uint8_t *data, size_t size)
 {
-	(void) regex_helper(data, size, std::regex_constants::basic);
-	return 0;
+    (void) regex_helper(data, size, std::regex_constants::basic);
+    return 0;
 }
 
 int regex_extended (const uint8_t *data, size_t size)
 {
-	(void) regex_helper(data, size, std::regex_constants::extended);
-	return 0;
+    (void) regex_helper(data, size, std::regex_constants::extended);
+    return 0;
 }
 
 int regex_awk (const uint8_t *data, size_t size)
 {
-	(void) regex_helper(data, size, std::regex_constants::awk);
-	return 0;
+    (void) regex_helper(data, size, std::regex_constants::awk);
+    return 0;
 }
 
 int regex_grep (const uint8_t *data, size_t size)
 {
-	(void) regex_helper(data, size, std::regex_constants::grep);
-	return 0;
+    (void) regex_helper(data, size, std::regex_constants::grep);
+    return 0;
 }
 
 int regex_egrep (const uint8_t *data, size_t size)
 {
-	(void) regex_helper(data, size, std::regex_constants::egrep);
-	return 0;
+    (void) regex_helper(data, size, std::regex_constants::egrep);
+    return 0;
 }
 
-// --	heap fuzzers
+// --   heap fuzzers
 int make_heap (const uint8_t *data, size_t size)
 {
-	Vec working(data, data + size);
-	std::make_heap(working.begin(), working.end());
+    Vec working(data, data + size);
+    std::make_heap(working.begin(), working.end());
 
-	if (!std::is_heap(working.begin(), working.end())) return 1;
-	if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
-	return 0;
+    if (!std::is_heap(working.begin(), working.end())) return 1;
+    if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
+    return 0;
 }
 
 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
-	Vec working(data, data + size);
-	auto iter = working.begin() + (size / 2);
-	std::make_heap(working.begin(), iter);
-	if (!std::is_heap(working.begin(), iter)) return 1;
+//  Make a heap from the first half of the data
+    Vec working(data, data + size);
+    auto iter = working.begin() + (size / 2);
+    std::make_heap(working.begin(), iter);
+    if (!std::is_heap(working.begin(), iter)) return 1;
 
-//	Now push the rest onto the heap, one at a time
-	++iter;
-	for (; iter != working.end(); ++iter) {
-		std::push_heap(working.begin(), iter);
-		if (!std::is_heap(working.begin(), iter)) return 2;	
-		}
+//  Now push the rest onto the heap, one at a time
+    ++iter;
+    for (; iter != working.end(); ++iter) {
+        std::push_heap(working.begin(), iter);
+        if (!std::is_heap(working.begin(), iter)) return 2;
+        }
 
-	if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
-	return 0;
+    if (!fuzzing::is_permutation(data, data + size, working.cbegin())) return 99;
+    return 0;
 }
 
 int pop_heap (const uint8_t *data, size_t size)
 {
-	if (size < 2) return 0;
-	Vec working(data, data + size);
-	std::make_heap(working.begin(), working.end());
+    if (size < 2) return 0;
+    Vec working(data, data + size);
+    std::make_heap(working.begin(), working.end());
 
-//	Pop things off, one at a time
-	auto iter = --working.end();
-	while (iter != working.begin()) {
-		std::pop_heap(working.begin(), iter);
-		if (!std::is_heap(working.begin(), --iter)) return 2;	
-		}
+//  Pop things off, one at a time
+    auto iter = --working.end();
+    while (iter != working.begin()) {
+        std::pop_heap(working.begin(), iter);
+        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)
 {
-	if (size < 2) return 0;
-	
-	const size_t pat_size = data[0] * (size - 1) / std::numeric_limits<uint8_t>::max();
-	assert(pat_size <= size - 1);
-	const uint8_t *pat_begin = data + 1;
-	const uint8_t *pat_end   = pat_begin + pat_size;
-	const uint8_t *data_end  = data + size;
-	assert(pat_end <= data_end);
-// 	std::cerr << "data[0] = " << size_t(data[0]) << " ";
-// 	std::cerr << "Pattern size = " << pat_size << "; corpus is " << size - 1 << std::endl;
-	auto it = std::search(pat_end, data_end, pat_begin, pat_end);
-	if (it != data_end) // not found
-		if (!std::equal(pat_begin, pat_end, it))
-			return 1;
-	return 0;
+    if (size < 2) return 0;
+
+    const size_t pat_size = data[0] * (size - 1) / std::numeric_limits<uint8_t>::max();
+    assert(pat_size <= size - 1);
+    const uint8_t *pat_begin = data + 1;
+    const uint8_t *pat_end   = pat_begin + pat_size;
+    const uint8_t *data_end  = data + size;
+    assert(pat_end <= data_end);
+//  std::cerr << "data[0] = " << size_t(data[0]) << " ";
+//  std::cerr << "Pattern size = " << pat_size << "; corpus is " << size - 1 << std::endl;
+    auto it = std::search(pat_end, data_end, pat_begin, pat_end);
+    if (it != data_end) // not found
+        if (!std::equal(pat_begin, pat_end, it))
+            return 1;
+    return 0;
 }
 
 template <typename S>
 static int search_helper (const uint8_t *data, size_t size)
 {
-	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));
-	if (it != data_end) // not found
-		if (!std::equal(pat_begin, pat_end, it))
-			return 1;
-	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));
+    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)
 // {
-// 	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)
 // {
-// 	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>
 static void set_helper (const uint8_t *data, size_t size, Vec &v1, Vec &v2)
 {
-	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());
-	std::sort(v2.begin(), v2.end());
+    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());
+    std::sort(v2.begin(), v2.end());
 }
 
 } // namespace fuzzing