base/value_iterators_unittest.cc - chromium/src - Git at Google

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "base/value_iterators.h"

 #include <type_traits>

 #include "base/memory/ptr_util.h"
 #include "base/values.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace base {

 namespace detail {

 namespace {

 // Implementation of std::equal variant that is missing in C++11.
 template <class BinaryPredicate, class InputIterator1, class InputIterator2>
 bool are_equal(InputIterator1 first1,
                InputIterator1 last1,
                InputIterator2 first2,
                InputIterator2 last2,
                BinaryPredicate pred) {
   for (; first1 != last1 && first2 != last2; ++first1, ++first2) {
     if (!pred(*first1, *first2))
       return false;
   }
   return first1 == last1 && first2 == last2;
 }

 }  // namespace

 TEST(ValueIteratorsTest, SameDictStorage) {
   static_assert(std::is_same<Value::DictStorage, DictStorage>::value,
                 "DictStorage differs between Value and Value Iterators.");
 }

 TEST(ValueIteratorsTest, IsAssignable) {
   static_assert(
       !std::is_assignable<dict_iterator::reference::first_type, std::string>(),
       "Can assign strings to dict_iterator");

   static_assert(
       std::is_assignable<dict_iterator::reference::second_type, Value>(),
       "Can't assign Values to dict_iterator");

   static_assert(!std::is_assignable<const_dict_iterator::reference::first_type,
                                     std::string>(),
                 "Can assign strings to const_dict_iterator");

   static_assert(
       !std::is_assignable<const_dict_iterator::reference::second_type, Value>(),
       "Can assign Values to const_dict_iterator");
 }

 TEST(ValueIteratorsTest, DictIteratorOperatorStar) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));

   using iterator = dict_iterator;
   iterator iter(storage.begin());
   EXPECT_EQ("0", (*iter).first);
   EXPECT_EQ(Value(0), (*iter).second);

   (*iter).second = Value(1);
   EXPECT_EQ(Value(1), *storage["0"]);
 }

 TEST(ValueIteratorsTest, DictIteratorOperatorArrow) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));

   using iterator = dict_iterator;
   iterator iter(storage.begin());
   EXPECT_EQ("0", iter->first);
   EXPECT_EQ(Value(0), iter->second);

   iter->second = Value(1);
   EXPECT_EQ(Value(1), *storage["0"]);
 }

 TEST(ValueIteratorsTest, DictIteratorPreIncrement) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));
   storage.emplace("1", std::make_unique<Value>(1));

   using iterator = dict_iterator;
   iterator iter(storage.begin());
   EXPECT_EQ("0", iter->first);
   EXPECT_EQ(Value(0), iter->second);

   iterator& iter_ref = ++iter;
   EXPECT_EQ(&iter, &iter_ref);

   EXPECT_EQ("1", iter_ref->first);
   EXPECT_EQ(Value(1), iter_ref->second);
 }

 TEST(ValueIteratorsTest, DictIteratorPostIncrement) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));
   storage.emplace("1", std::make_unique<Value>(1));

   using iterator = dict_iterator;
   iterator iter(storage.begin());
   iterator iter_old = iter++;

   EXPECT_EQ("0", iter_old->first);
   EXPECT_EQ(Value(0), iter_old->second);

   EXPECT_EQ("1", iter->first);
   EXPECT_EQ(Value(1), iter->second);
 }

 TEST(ValueIteratorsTest, DictIteratorPreDecrement) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));
   storage.emplace("1", std::make_unique<Value>(1));

   using iterator = dict_iterator;
   iterator iter(++storage.begin());
   EXPECT_EQ("1", iter->first);
   EXPECT_EQ(Value(1), iter->second);

   iterator& iter_ref = --iter;
   EXPECT_EQ(&iter, &iter_ref);

   EXPECT_EQ("0", iter_ref->first);
   EXPECT_EQ(Value(0), iter_ref->second);
 }

 TEST(ValueIteratorsTest, DictIteratorPostDecrement) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));
   storage.emplace("1", std::make_unique<Value>(1));

   using iterator = dict_iterator;
   iterator iter(++storage.begin());
   iterator iter_old = iter--;

   EXPECT_EQ("1", iter_old->first);
   EXPECT_EQ(Value(1), iter_old->second);

   EXPECT_EQ("0", iter->first);
   EXPECT_EQ(Value(0), iter->second);
 }

 TEST(ValueIteratorsTest, DictIteratorOperatorEQ) {
   DictStorage storage;
   using iterator = dict_iterator;
   EXPECT_EQ(iterator(storage.begin()), iterator(storage.begin()));
   EXPECT_EQ(iterator(storage.end()), iterator(storage.end()));
 }

 TEST(ValueIteratorsTest, DictIteratorOperatorNE) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));

   using iterator = dict_iterator;
   EXPECT_NE(iterator(storage.begin()), iterator(storage.end()));
 }

 TEST(ValueIteratorsTest, ConstDictIteratorOperatorStar) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));

   using iterator = const_dict_iterator;
   iterator iter(storage.begin());
   EXPECT_EQ("0", (*iter).first);
   EXPECT_EQ(Value(0), (*iter).second);
 }

 TEST(ValueIteratorsTest, ConstDictIteratorOperatorArrow) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));

   using iterator = const_dict_iterator;
   iterator iter(storage.begin());
   EXPECT_EQ("0", iter->first);
   EXPECT_EQ(Value(0), iter->second);
 }

 TEST(ValueIteratorsTest, ConstDictIteratorPreIncrement) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));
   storage.emplace("1", std::make_unique<Value>(1));

   using iterator = const_dict_iterator;
   iterator iter(storage.begin());
   EXPECT_EQ("0", iter->first);
   EXPECT_EQ(Value(0), iter->second);

   iterator& iter_ref = ++iter;
   EXPECT_EQ(&iter, &iter_ref);

   EXPECT_EQ("1", iter_ref->first);
   EXPECT_EQ(Value(1), iter_ref->second);
 }

 TEST(ValueIteratorsTest, ConstDictIteratorPostIncrement) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));
   storage.emplace("1", std::make_unique<Value>(1));

   using iterator = const_dict_iterator;
   iterator iter(storage.begin());
   iterator iter_old = iter++;

   EXPECT_EQ("0", iter_old->first);
   EXPECT_EQ(Value(0), iter_old->second);

   EXPECT_EQ("1", iter->first);
   EXPECT_EQ(Value(1), iter->second);
 }

 TEST(ValueIteratorsTest, ConstDictIteratorPreDecrement) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));
   storage.emplace("1", std::make_unique<Value>(1));

   using iterator = const_dict_iterator;
   iterator iter(++storage.begin());
   EXPECT_EQ("1", iter->first);
   EXPECT_EQ(Value(1), iter->second);

   iterator& iter_ref = --iter;
   EXPECT_EQ(&iter, &iter_ref);

   EXPECT_EQ("0", iter_ref->first);
   EXPECT_EQ(Value(0), iter_ref->second);
 }

 TEST(ValueIteratorsTest, ConstDictIteratorPostDecrement) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));
   storage.emplace("1", std::make_unique<Value>(1));

   using iterator = const_dict_iterator;
   iterator iter(++storage.begin());
   iterator iter_old = iter--;

   EXPECT_EQ("1", iter_old->first);
   EXPECT_EQ(Value(1), iter_old->second);

   EXPECT_EQ("0", iter->first);
   EXPECT_EQ(Value(0), iter->second);
 }

 TEST(ValueIteratorsTest, ConstDictIteratorOperatorEQ) {
   DictStorage storage;
   using iterator = const_dict_iterator;
   EXPECT_EQ(iterator(storage.begin()), iterator(storage.begin()));
   EXPECT_EQ(iterator(storage.end()), iterator(storage.end()));
 }

 TEST(ValueIteratorsTest, ConstDictIteratorOperatorNE) {
   DictStorage storage;
   storage.emplace("0", std::make_unique<Value>(0));

   using iterator = const_dict_iterator;
   EXPECT_NE(iterator(storage.begin()), iterator(storage.end()));
 }

 TEST(ValueIteratorsTest, DictIteratorProxy) {
   DictStorage storage;
   storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
   storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
   storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
   storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
   storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
   storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
   storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
   storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));

   using iterator = const_dict_iterator;
   using iterator_proxy = dict_iterator_proxy;
   iterator_proxy proxy(&storage);

   auto equal_to = [](const DictStorage::value_type& lhs,
                      const iterator::reference& rhs) {
     return std::tie(lhs.first, *lhs.second) == std::tie(rhs.first, rhs.second);
   };

   EXPECT_TRUE(are_equal(storage.begin(), storage.end(), proxy.begin(),
                         proxy.end(), equal_to));

   EXPECT_TRUE(are_equal(storage.rbegin(), storage.rend(), proxy.rbegin(),
                         proxy.rend(), equal_to));

   EXPECT_TRUE(are_equal(storage.cbegin(), storage.cend(), proxy.cbegin(),
                         proxy.cend(), equal_to));

   EXPECT_TRUE(are_equal(storage.crbegin(), storage.crend(), proxy.crbegin(),
                         proxy.crend(), equal_to));
 }

 TEST(ValueIteratorsTest, ConstDictIteratorProxy) {
   DictStorage storage;
   storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
   storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
   storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
   storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
   storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
   storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
   storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
   storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));

   using iterator = const_dict_iterator;
   using iterator_proxy = const_dict_iterator_proxy;
   iterator_proxy proxy(&storage);

   auto equal_to = [](const DictStorage::value_type& lhs,
                      const iterator::reference& rhs) {
     return std::tie(lhs.first, *lhs.second) == std::tie(rhs.first, rhs.second);
   };

   EXPECT_TRUE(are_equal(storage.begin(), storage.end(), proxy.begin(),
                         proxy.end(), equal_to));

   EXPECT_TRUE(are_equal(storage.rbegin(), storage.rend(), proxy.rbegin(),
                         proxy.rend(), equal_to));

   EXPECT_TRUE(are_equal(storage.cbegin(), storage.cend(), proxy.cbegin(),
                         proxy.cend(), equal_to));

   EXPECT_TRUE(are_equal(storage.crbegin(), storage.crend(), proxy.crbegin(),
                         proxy.crend(), equal_to));
 }

 }  // namespace detail

 }  // namespace base
	// Copyright 2017 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "base/value_iterators.h"

	#include <type_traits>

	#include "base/memory/ptr_util.h"
	#include "base/values.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace base {

	namespace detail {

	namespace {

	// Implementation of std::equal variant that is missing in C++11.
	template <class BinaryPredicate, class InputIterator1, class InputIterator2>
	bool are_equal(InputIterator1 first1,
	InputIterator1 last1,
	InputIterator2 first2,
	InputIterator2 last2,
	BinaryPredicate pred) {
	for (; first1 != last1 && first2 != last2; ++first1, ++first2) {
	if (!pred(first1, first2))
	return false;
	}
	return first1 == last1 && first2 == last2;
	}

	} // namespace

	TEST(ValueIteratorsTest, SameDictStorage) {
	static_assert(std::is_same<Value::DictStorage, DictStorage>::value,
	"DictStorage differs between Value and Value Iterators.");
	}

	TEST(ValueIteratorsTest, IsAssignable) {
	static_assert(
	!std::is_assignable<dict_iterator::reference::first_type, std::string>(),
	"Can assign strings to dict_iterator");

	static_assert(
	std::is_assignable<dict_iterator::reference::second_type, Value>(),
	"Can't assign Values to dict_iterator");

	static_assert(!std::is_assignable<const_dict_iterator::reference::first_type,
	std::string>(),
	"Can assign strings to const_dict_iterator");

	static_assert(
	!std::is_assignable<const_dict_iterator::reference::second_type, Value>(),
	"Can assign Values to const_dict_iterator");
	}

	TEST(ValueIteratorsTest, DictIteratorOperatorStar) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));

	using iterator = dict_iterator;
	iterator iter(storage.begin());
	EXPECT_EQ("0", (*iter).first);
	EXPECT_EQ(Value(0), (*iter).second);

	(*iter).second = Value(1);
	EXPECT_EQ(Value(1), *storage["0"]);
	}

	TEST(ValueIteratorsTest, DictIteratorOperatorArrow) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));

	using iterator = dict_iterator;
	iterator iter(storage.begin());
	EXPECT_EQ("0", iter->first);
	EXPECT_EQ(Value(0), iter->second);

	iter->second = Value(1);
	EXPECT_EQ(Value(1), *storage["0"]);
	}

	TEST(ValueIteratorsTest, DictIteratorPreIncrement) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));
	storage.emplace("1", std::make_unique<Value>(1));

	using iterator = dict_iterator;
	iterator iter(storage.begin());
	EXPECT_EQ("0", iter->first);
	EXPECT_EQ(Value(0), iter->second);

	iterator& iter_ref = ++iter;
	EXPECT_EQ(&iter, &iter_ref);

	EXPECT_EQ("1", iter_ref->first);
	EXPECT_EQ(Value(1), iter_ref->second);
	}

	TEST(ValueIteratorsTest, DictIteratorPostIncrement) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));
	storage.emplace("1", std::make_unique<Value>(1));

	using iterator = dict_iterator;
	iterator iter(storage.begin());
	iterator iter_old = iter++;

	EXPECT_EQ("0", iter_old->first);
	EXPECT_EQ(Value(0), iter_old->second);

	EXPECT_EQ("1", iter->first);
	EXPECT_EQ(Value(1), iter->second);
	}

	TEST(ValueIteratorsTest, DictIteratorPreDecrement) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));
	storage.emplace("1", std::make_unique<Value>(1));

	using iterator = dict_iterator;
	iterator iter(++storage.begin());
	EXPECT_EQ("1", iter->first);
	EXPECT_EQ(Value(1), iter->second);

	iterator& iter_ref = --iter;
	EXPECT_EQ(&iter, &iter_ref);

	EXPECT_EQ("0", iter_ref->first);
	EXPECT_EQ(Value(0), iter_ref->second);
	}

	TEST(ValueIteratorsTest, DictIteratorPostDecrement) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));
	storage.emplace("1", std::make_unique<Value>(1));

	using iterator = dict_iterator;
	iterator iter(++storage.begin());
	iterator iter_old = iter--;

	EXPECT_EQ("1", iter_old->first);
	EXPECT_EQ(Value(1), iter_old->second);

	EXPECT_EQ("0", iter->first);
	EXPECT_EQ(Value(0), iter->second);
	}

	TEST(ValueIteratorsTest, DictIteratorOperatorEQ) {
	DictStorage storage;
	using iterator = dict_iterator;
	EXPECT_EQ(iterator(storage.begin()), iterator(storage.begin()));
	EXPECT_EQ(iterator(storage.end()), iterator(storage.end()));
	}

	TEST(ValueIteratorsTest, DictIteratorOperatorNE) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));

	using iterator = dict_iterator;
	EXPECT_NE(iterator(storage.begin()), iterator(storage.end()));
	}

	TEST(ValueIteratorsTest, ConstDictIteratorOperatorStar) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));

	using iterator = const_dict_iterator;
	iterator iter(storage.begin());
	EXPECT_EQ("0", (*iter).first);
	EXPECT_EQ(Value(0), (*iter).second);
	}

	TEST(ValueIteratorsTest, ConstDictIteratorOperatorArrow) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));

	using iterator = const_dict_iterator;
	iterator iter(storage.begin());
	EXPECT_EQ("0", iter->first);
	EXPECT_EQ(Value(0), iter->second);
	}

	TEST(ValueIteratorsTest, ConstDictIteratorPreIncrement) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));
	storage.emplace("1", std::make_unique<Value>(1));

	using iterator = const_dict_iterator;
	iterator iter(storage.begin());
	EXPECT_EQ("0", iter->first);
	EXPECT_EQ(Value(0), iter->second);

	iterator& iter_ref = ++iter;
	EXPECT_EQ(&iter, &iter_ref);

	EXPECT_EQ("1", iter_ref->first);
	EXPECT_EQ(Value(1), iter_ref->second);
	}

	TEST(ValueIteratorsTest, ConstDictIteratorPostIncrement) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));
	storage.emplace("1", std::make_unique<Value>(1));

	using iterator = const_dict_iterator;
	iterator iter(storage.begin());
	iterator iter_old = iter++;

	EXPECT_EQ("0", iter_old->first);
	EXPECT_EQ(Value(0), iter_old->second);

	EXPECT_EQ("1", iter->first);
	EXPECT_EQ(Value(1), iter->second);
	}

	TEST(ValueIteratorsTest, ConstDictIteratorPreDecrement) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));
	storage.emplace("1", std::make_unique<Value>(1));

	using iterator = const_dict_iterator;
	iterator iter(++storage.begin());
	EXPECT_EQ("1", iter->first);
	EXPECT_EQ(Value(1), iter->second);

	iterator& iter_ref = --iter;
	EXPECT_EQ(&iter, &iter_ref);

	EXPECT_EQ("0", iter_ref->first);
	EXPECT_EQ(Value(0), iter_ref->second);
	}

	TEST(ValueIteratorsTest, ConstDictIteratorPostDecrement) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));
	storage.emplace("1", std::make_unique<Value>(1));

	using iterator = const_dict_iterator;
	iterator iter(++storage.begin());
	iterator iter_old = iter--;

	EXPECT_EQ("1", iter_old->first);
	EXPECT_EQ(Value(1), iter_old->second);

	EXPECT_EQ("0", iter->first);
	EXPECT_EQ(Value(0), iter->second);
	}

	TEST(ValueIteratorsTest, ConstDictIteratorOperatorEQ) {
	DictStorage storage;
	using iterator = const_dict_iterator;
	EXPECT_EQ(iterator(storage.begin()), iterator(storage.begin()));
	EXPECT_EQ(iterator(storage.end()), iterator(storage.end()));
	}

	TEST(ValueIteratorsTest, ConstDictIteratorOperatorNE) {
	DictStorage storage;
	storage.emplace("0", std::make_unique<Value>(0));

	using iterator = const_dict_iterator;
	EXPECT_NE(iterator(storage.begin()), iterator(storage.end()));
	}

	TEST(ValueIteratorsTest, DictIteratorProxy) {
	DictStorage storage;
	storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
	storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
	storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
	storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
	storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
	storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
	storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
	storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));

	using iterator = const_dict_iterator;
	using iterator_proxy = dict_iterator_proxy;
	iterator_proxy proxy(&storage);

	auto equal_to = [](const DictStorage::value_type& lhs,
	const iterator::reference& rhs) {
	return std::tie(lhs.first, *lhs.second) == std::tie(rhs.first, rhs.second);
	};

	EXPECT_TRUE(are_equal(storage.begin(), storage.end(), proxy.begin(),
	proxy.end(), equal_to));

	EXPECT_TRUE(are_equal(storage.rbegin(), storage.rend(), proxy.rbegin(),
	proxy.rend(), equal_to));

	EXPECT_TRUE(are_equal(storage.cbegin(), storage.cend(), proxy.cbegin(),
	proxy.cend(), equal_to));

	EXPECT_TRUE(are_equal(storage.crbegin(), storage.crend(), proxy.crbegin(),
	proxy.crend(), equal_to));
	}

	TEST(ValueIteratorsTest, ConstDictIteratorProxy) {
	DictStorage storage;
	storage.emplace("null", std::make_unique<Value>(Value::Type::NONE));
	storage.emplace("bool", std::make_unique<Value>(Value::Type::BOOLEAN));
	storage.emplace("int", std::make_unique<Value>(Value::Type::INTEGER));
	storage.emplace("double", std::make_unique<Value>(Value::Type::DOUBLE));
	storage.emplace("string", std::make_unique<Value>(Value::Type::STRING));
	storage.emplace("blob", std::make_unique<Value>(Value::Type::BINARY));
	storage.emplace("dict", std::make_unique<Value>(Value::Type::DICTIONARY));
	storage.emplace("list", std::make_unique<Value>(Value::Type::LIST));

	using iterator = const_dict_iterator;
	using iterator_proxy = const_dict_iterator_proxy;
	iterator_proxy proxy(&storage);

	auto equal_to = [](const DictStorage::value_type& lhs,
	const iterator::reference& rhs) {
	return std::tie(lhs.first, *lhs.second) == std::tie(rhs.first, rhs.second);
	};

	EXPECT_TRUE(are_equal(storage.begin(), storage.end(), proxy.begin(),
	proxy.end(), equal_to));

	EXPECT_TRUE(are_equal(storage.rbegin(), storage.rend(), proxy.rbegin(),
	proxy.rend(), equal_to));

	EXPECT_TRUE(are_equal(storage.cbegin(), storage.cend(), proxy.cbegin(),
	proxy.cend(), equal_to));

	EXPECT_TRUE(are_equal(storage.crbegin(), storage.crend(), proxy.crbegin(),
	proxy.crend(), equal_to));
	}

	} // namespace detail

	} // namespace base