From 64fa058f6bee1bf66f3ca1138572eeedbc3563a3 Mon Sep 17 00:00:00 2001 From: John Wellbelove Date: Fri, 26 Aug 2022 09:49:13 +0100 Subject: [PATCH] Work in progress --- include/etl/circular_iterator.h | 408 ++++++++++++++++++++++ include/etl/fixed_iterator.h | 18 +- test/test_circular_iterator.cpp | 578 ++++++++++++++++++++++++++++++++ test/vs2019/etl.vcxproj | 1 + test/vs2019/etl.vcxproj.filters | 3 + 5 files changed, 998 insertions(+), 10 deletions(-) create mode 100644 include/etl/circular_iterator.h create mode 100644 test/test_circular_iterator.cpp diff --git a/include/etl/circular_iterator.h b/include/etl/circular_iterator.h new file mode 100644 index 00000000..764f1467 --- /dev/null +++ b/include/etl/circular_iterator.h @@ -0,0 +1,408 @@ +///\file + +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2022 John Wellbelove + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#ifndef ETL_CIRCULAR_ITERATOR_INCLUDED +#define ETL_CIRCULAR_ITERATOR_INCLUDED + +#include "platform.h" +#include "iterator.h" +#include "span.h" + +///\defgroup iterator Iterator types + +namespace etl +{ + /// A circular iterator class. + /// This iterator can be given a pair of iterator values, which will loop if the start or end of the range is reached. + ///\ingroup iterator + template + class circular_iterator : etl::iterator::iterator_category, typename etl::iterator_traits::value_type> + { + public: + + typedef typename etl::iterator_traits::value_type value_type; + typedef typename etl::iterator_traits::difference_type difference_type; + typedef typename etl::iterator_traits::pointer pointer; + typedef typename etl::iterator_traits::reference reference; + typedef typename etl::iterator_traits::iterator_category iterator_category; + + //*************************************************************************** + /// Default constructor. + //*************************************************************************** + circular_iterator() + : itr_begin(TIterator()) + , itr_end(TIterator()) + , itr(TIterator()) + { + } + + //*************************************************************************** + /// Construct from iterators. + //*************************************************************************** + circular_iterator(TIterator itr_begin_, TIterator itr_end_) + : itr_begin(itr_begin_) + , itr_end(itr_end_) + , itr(itr_begin_) + { + } + + //*************************************************************************** + /// Construct from span. + //*************************************************************************** + template + circular_iterator(const etl::span& span_) + : itr_begin(span_.begin()) + , itr_end(span_.end()) + , itr(itr_begin) + { + } + + //*************************************************************************** + /// Copy constructor + //*************************************************************************** + circular_iterator(const circular_iterator& other) + : itr_begin(other.itr_begin) + , itr_end(other.itr_end) + , itr(other.itr) + { + } + + //*************************************************************************** + /// Beginning of the range. + //*************************************************************************** + TIterator begin() const + { + return itr_begin; + } + + //*************************************************************************** + /// End of the range. + //*************************************************************************** + TIterator end() const + { + return itr_end; + } + + //*************************************************************************** + /// How long is the range? + //*************************************************************************** + size_t size() const + { + return etl::distance(itr_begin, itr_end); + } + + //*************************************************************************** + /// Is there nothing to iteratte over? + //*************************************************************************** + bool empty() const + { + return (itr_begin == itr_end); + } + + //*************************************************************************** + /// Increment. + //*************************************************************************** + circular_iterator& operator ++() + { + if (++itr == itr_end) + { + itr = itr_begin; + } + + return *this; + } + + //*************************************************************************** + /// Increment. + //*************************************************************************** + circular_iterator operator ++(int) + { + circular_iterator original(*this); + + ++(*this); + + return (original); + } + + //*************************************************************************** + /// Decrement. + //*************************************************************************** + circular_iterator& operator --() + { + if (itr == itr_begin) + { + typename etl::reverse_iterator ritr(itr_end); + ++ritr; + itr = ritr.base(); + } + else + { + --itr; + } + + return *this; + } + + //*************************************************************************** + /// Decrement. + //*************************************************************************** + circular_iterator operator --(int) + { + circular_iterator original(*this); + + --(*this); + + return (original); + } + + //*************************************************************************** + /// Dereference operator. + //*************************************************************************** + value_type operator *() + { + return *itr; + } + + //*************************************************************************** + /// Dereference operator. + //*************************************************************************** + const value_type operator *() const + { + return *itr; + } + + //*************************************************************************** + /// -> operator. + //*************************************************************************** + TIterator operator ->() + { + return itr; + } + + //*************************************************************************** + /// -> operator. + //*************************************************************************** + const TIterator operator ->() const + { + return itr; + } + + //*************************************************************************** + /// Conversion operator. + //*************************************************************************** + operator TIterator() const + { + return itr; + } + + //*************************************************************************** + /// += operator. + //*************************************************************************** + circular_iterator& operator +=(difference_type offset) + { + if (offset != 0) + { + if (offset > 0) + { + difference_type distance_to_end = etl::distance(itr, itr_end); + offset %= difference_type(size()); + + if (distance_to_end > offset) + { + etl::advance(itr, offset); + } + else + { + offset -= distance_to_end; + itr = itr_begin; + etl::advance(itr, offset); + } + } + else + { + difference_type distance_to_begin = etl::distance(itr_begin, itr); + offset %= difference_type(size()); + + if (distance_to_begin > -offset) + { + etl::advance(itr, offset); + } + else + { + offset += distance_to_begin; + + typename etl::reverse_iterator ritr(itr_end); + etl::advance(ritr, -offset); + itr = ritr.base(); + } + } + } + + return *this; + } + + //*************************************************************************** + /// -= operator. + //*************************************************************************** + circular_iterator& operator -=(typename etl::iterator_traits::difference_type offset) + { + return operator +=(-offset); + } + + //*************************************************************************** + /// Assignment from span. + //*************************************************************************** + circular_iterator& operator =(const etl::span& span_) + { + itr_begin = span_.begin(); + itr_end = span_.end(); + itr = itr_begin; + + return *this; + } + + //*************************************************************************** + /// Assignment from circular_iterator. + //*************************************************************************** + circular_iterator& operator =(circular_iterator other) + { + itr_begin = other.itr_begin; + itr_end = other.itr_end; + itr = other.itr; + + return *this; + } + + private: + + TIterator itr_begin; ///< The underlying begin iterator. + TIterator itr_end; ///< The underlying end iterator. + TIterator itr; ///< The underlying iterator. + }; + + //***************************************************************************** + /// + difference operator. + //***************************************************************************** + template + etl::circular_iterator operator +(etl::circular_iterator& lhs, + typename etl::iterator_traits::difference_type offset) + { + etl::circular_iterator result(lhs); + result += offset; + + return result; + } + + //***************************************************************************** + /// - difference operator. + //***************************************************************************** + template + etl::circular_iterator operator -(etl::circular_iterator& lhs, + typename etl::iterator_traits::difference_type offset) + { + etl::circular_iterator result(lhs); + result -= offset; + + return result; + } + + ////***************************************************************************** + ///// - circular_iterator operator. + ////***************************************************************************** + //template + //typename etl::iterator_traits::difference_type operator -(etl::circular_iterator& lhs, + // etl::circular_iterator& rhs) + //{ + // return TIterator(lhs) - TIterator(rhs); + //} + + //***************************************************************************** + /// Equality operator. circular_iterator == circular_iterator. + //***************************************************************************** + template + bool operator ==(const etl::circular_iterator& lhs, + const etl::circular_iterator& rhs) + { + return TIterator(lhs) == TIterator(rhs); + } + + //***************************************************************************** + /// Equality operator. circular_iterator == iterator. + //***************************************************************************** + template + bool operator ==(const etl::circular_iterator& lhs, + TIterator rhs) + { + return TIterator(lhs) == rhs; + } + + //***************************************************************************** + /// Equality operator. iterator == circular_iterator. + //***************************************************************************** + template + bool operator ==(TIterator lhs, + const etl::circular_iterator& rhs) + { + return lhs == TIterator(rhs); + } + + + //***************************************************************************** + /// Inequality operator. circular_iterator == circular_iterator. + //***************************************************************************** + template + bool operator !=(const etl::circular_iterator& lhs, + const etl::circular_iterator& rhs) + { + return !(lhs == rhs); + } + + //***************************************************************************** + /// Inequality operator. circular_iterator == iterator. + //***************************************************************************** + template + bool operator !=(const etl::circular_iterator& lhs, + TIterator rhs) + { + return !(lhs == rhs); + } + + //***************************************************************************** + /// Inequality operator. iterator == circular_iterator. + //***************************************************************************** + template + bool operator !=(TIterator& lhs, + const etl::circular_iterator& rhs) + { + return !(lhs == rhs); + } +} + +#endif diff --git a/include/etl/fixed_iterator.h b/include/etl/fixed_iterator.h index d20d09d7..74be0851 100644 --- a/include/etl/fixed_iterator.h +++ b/include/etl/fixed_iterator.h @@ -34,8 +34,6 @@ SOFTWARE. #include "platform.h" #include "iterator.h" -#include "iterator.h" - ///\defgroup iterator Iterator types namespace etl @@ -208,8 +206,8 @@ namespace etl /// - fixed_iterator operator. //***************************************************************************** template - typename etl::iterator_traits::difference_type operator -(etl::fixed_iterator& lhs, - etl::fixed_iterator& rhs) + typename etl::iterator_traits::difference_type operator -(const etl::fixed_iterator& lhs, + const etl::fixed_iterator& rhs) { return TIterator(lhs) - TIterator(rhs); } @@ -219,7 +217,7 @@ namespace etl //***************************************************************************** template bool operator ==(const etl::fixed_iterator& lhs, - const etl::fixed_iterator& rhs) + const etl::fixed_iterator& rhs) { return TIterator(lhs) == TIterator(rhs); } @@ -229,7 +227,7 @@ namespace etl //***************************************************************************** template bool operator ==(const etl::fixed_iterator& lhs, - TIterator rhs) + TIterator rhs) { return TIterator(lhs) == rhs; } @@ -239,7 +237,7 @@ namespace etl //***************************************************************************** template bool operator ==(TIterator lhs, - const etl::fixed_iterator& rhs) + const etl::fixed_iterator& rhs) { return lhs == TIterator(rhs); } @@ -250,7 +248,7 @@ namespace etl //***************************************************************************** template bool operator !=(const etl::fixed_iterator& lhs, - const etl::fixed_iterator& rhs) + const etl::fixed_iterator& rhs) { return !(lhs == rhs); } @@ -260,7 +258,7 @@ namespace etl //***************************************************************************** template bool operator !=(const etl::fixed_iterator& lhs, - TIterator rhs) + TIterator rhs) { return !(lhs == rhs); } @@ -270,7 +268,7 @@ namespace etl //***************************************************************************** template bool operator !=(TIterator& lhs, - const etl::fixed_iterator& rhs) + const etl::fixed_iterator& rhs) { return !(lhs == rhs); } diff --git a/test/test_circular_iterator.cpp b/test/test_circular_iterator.cpp new file mode 100644 index 00000000..3e2505fc --- /dev/null +++ b/test/test_circular_iterator.cpp @@ -0,0 +1,578 @@ +/****************************************************************************** +The MIT License(MIT) + +Embedded Template Library. +https://github.com/ETLCPP/etl +https://www.etlcpp.com + +Copyright(c) 2022 John Wellbelove + +Permission is hereby granted, free of charge, to any person obtaining data copy +of this software and associated documentation ciles(the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and / or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions : + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +******************************************************************************/ + +#include "unit_test_framework.h" +#include +#include + +#include "etl/circular_iterator.h" + +//template +//std::ostream& operator << (std::ostream& os, const etl::circular_iterator& ci) +//{ +// os << ci.begin() "," << ci.end(); +// +// return os; +//} + +namespace +{ + using Data = std::list; + + SUITE(test_cixed_iterator) + { + //************************************************************************* + TEST(test_default_constructor) + { + etl::circular_iterator ci; + + CHECK_EQUAL(0U, size_t(std::distance(ci.begin(), ci.end()))); + CHECK_EQUAL(0U, ci.size()); + } + + //************************************************************************* + TEST(test_constructor_from_iterators) + { + const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci(std::begin(data), std::end(data)); + + CHECK(data.begin() == ci.begin()); + CHECK(data.end() == ci.end()); + CHECK_EQUAL(data.size(), size_t(std::distance(ci.begin(), ci.end()))); + CHECK_EQUAL(data.size(), ci.size()); + } + + //************************************************************************* + TEST(test_constructor_from_reverse_iterators) + { + const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + + CHECK(data.rbegin() == ci.begin()); + CHECK(data.rend() == ci.end()); + CHECK_EQUAL(data.size(), size_t(std::distance(ci.begin(), ci.end()))); + CHECK_EQUAL(data.size(), ci.size()); + } + + //************************************************************************* + TEST(test_constructor_from_span) + { + const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + const etl::span sp(std::begin(data), std::end(data)); + + etl::circular_iterator ci(sp); + + CHECK(std::begin(data) == ci.begin()); + CHECK(std::end(data) == ci.end()); + CHECK_EQUAL(sp.size(), size_t(std::distance(ci.begin(), ci.end()))); + CHECK_EQUAL(sp.size(), ci.size()); + } + + //************************************************************************* + TEST(test_copy_constructor) + { + int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + const etl::circular_iterator ci1(std::begin(data), std::end(data)); + etl::circular_iterator ci2(ci1); + + CHECK(ci1.begin() == ci2.begin()); + CHECK(ci1.end() == ci2.end()); + CHECK_EQUAL(ci1.size(), ci2.size()); + } + + //************************************************************************* + TEST(test_assignment_from_circular_iterator) + { + const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci1(std::begin(data), std::end(data)); + etl::circular_iteratorci2; + ci2 = ci1; + + CHECK(ci1.begin() == ci2.begin()); + CHECK(ci1.end() == ci2.end()); + CHECK_EQUAL(ci1.size(), ci2.size()); + } + + //************************************************************************* + TEST(test_assignment_from_span) + { + int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::span sp(std::begin(data), std::end(data)); + + etl::circular_iterator ci; + ci = sp; + + CHECK(std::begin(data) == ci.begin()); + CHECK(std::end(data) == ci.end()); + CHECK_EQUAL(sp.size(), size_t(std::distance(ci.begin(), ci.end()))); + CHECK_EQUAL(sp.size(), ci.size()); + } + + //************************************************************************* + TEST(test_pre_increment) + { + const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci(std::begin(data), std::end(data)); + + for (int i = 1; i < 21; ++i) + { + Data::const_iterator itr = data.begin(); + std::advance(itr, i % 10); + CHECK_EQUAL(*itr, *++ci); + } + } + + //************************************************************************* + TEST(test_post_increment) + { + const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci(std::begin(data), std::end(data)); + + for (int i = 0; i < 20; ++i) + { + Data::const_iterator itr = data.begin(); + std::advance(itr, i % 10); + CHECK_EQUAL(*itr, *ci++); + } + } + + //************************************************************************* + TEST(test_pre_increment_reverse_iterator) + { + const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + + for (int i = 1; i < 21; ++i) + { + Data::const_reverse_iterator itr = data.rbegin(); + std::advance(itr, i % 10); + CHECK_EQUAL(*itr, *++ci); + } + } + + //************************************************************************* + TEST(test_post_increment_reverse_iterator) + { + const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + + for (int i = 0; i < 20; ++i) + { + Data::const_reverse_iterator itr = data.rbegin(); + std::advance(itr, i % 10); + CHECK_EQUAL(*itr, *ci++); + } + } + + //************************************************************************* + TEST(test_pre_decrement) + { + const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci(std::begin(data), std::end(data)); + + for (int i = 0; i < 20; ++i) + { + Data::const_reverse_iterator itr = data.rbegin(); + std::advance(itr, i % 10); + CHECK_EQUAL(*itr, *--ci); + } + } + + //************************************************************************* + TEST(test_pre_decrement_reverse_iterator) + { + const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + + for (int i = 0; i < 20; ++i) + { + Data::const_iterator itr = data.begin(); + std::advance(itr, i % 10); + CHECK_EQUAL(*itr, *--ci); + } + } + + //************************************************************************* + TEST(test_post_decrement) + { + const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci(std::begin(data), std::end(data)); + ci--; + + for (int i = 0; i < 20; ++i) + { + Data::const_reverse_iterator itr = data.rbegin(); + std::advance(itr, i % 10); + CHECK_EQUAL(*itr, *ci--); + } + } + + //************************************************************************* + TEST(test_post_decrement_reverse_iterator) + { + const Data data = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci(std::rbegin(data), std::rend(data)); + ci--; + + for (int i = 0; i < 20; ++i) + { + Data::const_iterator itr = data.begin(); + std::advance(itr, i % 10); + CHECK_EQUAL(*itr, *ci--); + } + } + + //************************************************************************* + TEST(test_member_dereference_operator) + { + struct Test + { + int data; + int b; + }; + + Test test[] = { { 1, 2 }, { 3, 4 }, { 5, 6 } }; + + etl::circular_iterator ci(std::begin(test), std::end(test)); + + CHECK_EQUAL(test[0].data, ci->data); + CHECK_EQUAL(test[0].b, ci->b); + + *ci = { 7, 8 }; + + CHECK_EQUAL(test[0].data, ci->data); + CHECK_EQUAL(test[0].b, ci->b); + + ++ci; + CHECK_EQUAL(test[1].data, ci->data); + CHECK_EQUAL(test[1].b, ci->b); + + ++ci; + CHECK_EQUAL(test[2].data, ci->data); + CHECK_EQUAL(test[2].b, ci->b); + } + + //************************************************************************* + TEST(test_conversion_operator) + { + const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator ci(std::begin(data), std::end(data)); + + CHECK_EQUAL(data, ci); + + ++ci; + CHECK_EQUAL(data + 1, ci); + + ++ci; + CHECK_EQUAL(data + 2, ci); + } + + //************************************************************************* + TEST(test_operator_plus_equals) + { + const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + for (int step = 1; step < 20; ++step) + { + etl::circular_iterator ci(std::begin(data), std::end(data)); + + for (int i = 0; i < 20; i += step) + { + CHECK_EQUAL(data[i % 10], *ci); + ci += step; + } + } + } + + //************************************************************************* + TEST(test_operator_plus) + { + const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + for (int step = 1; step < 20; ++step) + { + etl::circular_iterator ci(std::begin(data), std::end(data)); + + for (int i = 0; i < 20; i += step) + { + CHECK_EQUAL(data[i % 10], *ci); + ci = ci + step; + } + } + } + + //************************************************************************* + TEST(test_operator_minus_equals) + { + const int data[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; + + etl::circular_iterator initial(std::begin(data), std::end(data)); + etl::circular_iterator ci; + int step; + + step = 1; + ci = initial; + + for (int i = 0; i < 20; i += step) + { + CHECK_EQUAL(data[(10 - i) % 10], *ci); + ci -= step; + } + + //step = 2; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 3; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 4; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 5; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 6; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 7; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 8; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 9; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 10; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 11; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 12; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 13; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 14; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 15; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 16; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 17; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 18; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 19; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + + //step = 20; + //ci = initial; + + //for (int i = 0; i < 20; i += step) + //{ + // CHECK_EQUAL(data[abs(i - step) % 10], *ci); + // ci -= step; + //} + } + + ////************************************************************************* + //TEST(test_operator_minus) + //{ + // int compare[] = { 1, 2, 3, 4 }; + + // etl::circular_iterator ci = &compare[1]; + + // for (int i = 0; i < 10; ++i) + // { + // CHECK_EQUAL(compare[1], *ci); + // ci = ci - 1; + // } + //} + + ////************************************************************************* + //TEST(test_assignment) + //{ + // int data; + // int b; + + // etl::circular_iterator ci = &data; + // ci = &b; + + // CHECK_EQUAL(&b, ci); + + // ci = &data; + + // CHECK_EQUAL(&data, ci); + //} + + ////************************************************************************* + //TEST(test_equality) + //{ + // int data; + // int b; + + // etl::circular_iterator ci1 = &data; + // etl::circular_iterator ci2 = &data; + // etl::circular_iterator ci3 = &b; + + // CHECK(ci1 == ci2); + // CHECK(ci1 != ci3); + //} + }; +} diff --git a/test/vs2019/etl.vcxproj b/test/vs2019/etl.vcxproj index ba2640b6..16247ec6 100644 --- a/test/vs2019/etl.vcxproj +++ b/test/vs2019/etl.vcxproj @@ -11270,6 +11270,7 @@ + diff --git a/test/vs2019/etl.vcxproj.filters b/test/vs2019/etl.vcxproj.filters index ee3af104..a1e03dd3 100644 --- a/test/vs2019/etl.vcxproj.filters +++ b/test/vs2019/etl.vcxproj.filters @@ -3353,6 +3353,9 @@ Tests\Binary + + Tests\Memory & Iterators +