contiguous_iterator_unittest.cc 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309
  1. // Copyright 2020 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "base/containers/contiguous_iterator.h"
  5. #include <array>
  6. #include <deque>
  7. #include <forward_list>
  8. #include <iterator>
  9. #include <string>
  10. #include <tuple>
  11. #include <type_traits>
  12. #include <utility>
  13. #include <valarray>
  14. #include <vector>
  15. #include "base/containers/span.h"
  16. #include "base/strings/string_piece.h"
  17. #include "testing/gtest/include/gtest/gtest.h"
  18. namespace base {
  19. TEST(ContiguousIteratorTest, ForwardIterator) {
  20. using ForwardIterator = std::forward_list<int>::iterator;
  21. static_assert(std::is_same<std::forward_iterator_tag,
  22. typename std::iterator_traits<
  23. ForwardIterator>::iterator_category>::value,
  24. "Error: The iterator_category of ForwardIterator is not "
  25. "std::forward_iterator_tag.");
  26. static_assert(
  27. !IsContiguousIterator<ForwardIterator>::value,
  28. "Error: ForwardIterator should not be considered a contiguous iterator.");
  29. static_assert(!IsContiguousIterator<const ForwardIterator>::value,
  30. "Error: const ForwardIterator should not be considered a "
  31. "contiguous iterator.");
  32. static_assert(!IsContiguousIterator<ForwardIterator&>::value,
  33. "Error: ForwardIterator& should not be considered a contiguous "
  34. "iterator.");
  35. static_assert(!IsContiguousIterator<const ForwardIterator&>::value,
  36. "Error: const ForwardIterator& should not be considered a "
  37. "contiguous iterator.");
  38. }
  39. TEST(ContiguousIteratorTest, BidirectionalIterator) {
  40. using BidirectionalIterator = std::set<int>::iterator;
  41. static_assert(
  42. std::is_same<std::bidirectional_iterator_tag,
  43. typename std::iterator_traits<
  44. BidirectionalIterator>::iterator_category>::value,
  45. "Error: The iterator_category of BidirectionalIterator is not "
  46. "std::bidirectional_iterator_tag.");
  47. static_assert(!IsContiguousIterator<BidirectionalIterator>::value,
  48. "Error: BidirectionalIterator should not be considered a "
  49. "contiguous iterator.");
  50. static_assert(!IsContiguousIterator<const BidirectionalIterator>::value,
  51. "Error: const BidirectionalIterator should not be considered a "
  52. "contiguous iterator.");
  53. static_assert(!IsContiguousIterator<BidirectionalIterator&>::value,
  54. "Error: BidirectionalIterator& should not be considered a "
  55. "contiguous iterator.");
  56. static_assert(!IsContiguousIterator<const BidirectionalIterator&>::value,
  57. "Error: const BidirectionalIterator& should not be considered "
  58. "a contiguous iterator.");
  59. static_assert(!IsContiguousIterator<
  60. std::reverse_iterator<BidirectionalIterator>>::value,
  61. "Error: A reverse BidirectionalIterator should not be "
  62. "considered a contiguous iterator.");
  63. }
  64. TEST(ContiguousIteratorTest, RandomAccessIterator) {
  65. using RandomAccessIterator = std::deque<int>::iterator;
  66. static_assert(
  67. std::is_same<std::random_access_iterator_tag,
  68. typename std::iterator_traits<
  69. RandomAccessIterator>::iterator_category>::value,
  70. "Error: The iterator_category of RandomAccessIterator is not "
  71. "std::random_access_iterator_tag.");
  72. static_assert(!IsContiguousIterator<RandomAccessIterator>::value,
  73. "Error: RandomAccessIterator should not be considered a "
  74. "contiguous iterator.");
  75. static_assert(!IsContiguousIterator<const RandomAccessIterator>::value,
  76. "Error: const RandomAccessIterator should not be considered a "
  77. "contiguous iterator.");
  78. static_assert(!IsContiguousIterator<RandomAccessIterator&>::value,
  79. "Error: RandomAccessIterator& should not be considered a "
  80. "contiguous iterator.");
  81. static_assert(!IsContiguousIterator<const RandomAccessIterator&>::value,
  82. "Error: const RandomAccessIterator& should not be considered "
  83. "a contiguous iterator.");
  84. static_assert(
  85. !IsContiguousIterator<std::reverse_iterator<RandomAccessIterator>>::value,
  86. "Error: A reverse RandomAccessIterator should not be "
  87. "considered a contiguous iterator.");
  88. }
  89. TEST(ContiguousIterator, Pointer) {
  90. static_assert(IsContiguousIterator<int*>::value,
  91. "Error: int* should be considered a contiguous iterator.");
  92. static_assert(
  93. IsContiguousIterator<int* const>::value,
  94. "Error: int* const should be considered a contiguous iterator.");
  95. static_assert(!IsContiguousIterator<void (*)()>::value,
  96. "Error: A function pointer should not be considered a "
  97. "contiguous iterator.");
  98. }
  99. TEST(ContiguousIterator, VectorInt) {
  100. static_assert(IsContiguousIterator<std::vector<int>::iterator>::value,
  101. "Error: std::vector<int>::iterator should be considered a "
  102. "contiguous iterator.");
  103. static_assert(IsContiguousIterator<std::vector<int>::const_iterator>::value,
  104. "Error: std::vector<int>::const_iterator should be considered "
  105. "a contiguous iterator.");
  106. static_assert(
  107. !IsContiguousIterator<std::vector<int>::reverse_iterator>::value,
  108. "Error: std::vector<int>::reverse_iterator should not be considered a "
  109. "contiguous iterator.");
  110. static_assert(
  111. !IsContiguousIterator<std::vector<int>::const_reverse_iterator>::value,
  112. "Error: std::vector<int>::const_reverse_iterator should not be "
  113. "considered a contiguous iterator.");
  114. }
  115. TEST(ContiguousIterator, VectorString) {
  116. static_assert(IsContiguousIterator<std::vector<std::string>::iterator>::value,
  117. "Error: std::vector<std::string>::iterator should be "
  118. "considered a contiguous iterator.");
  119. static_assert(
  120. IsContiguousIterator<std::vector<std::string>::const_iterator>::value,
  121. "Error: std::vector<std::string>::const_iterator should be considered a "
  122. "contiguous iterator.");
  123. static_assert(
  124. !IsContiguousIterator<std::vector<std::string>::reverse_iterator>::value,
  125. "Error: std::vector<std::string>::reverse_iterator should not be "
  126. "considered a contiguous iterator.");
  127. static_assert(!IsContiguousIterator<
  128. std::vector<std::string>::const_reverse_iterator>::value,
  129. "Error: std::vector<std::string>::const_reverse_iterator "
  130. "should not be considered a contiguous iterator.");
  131. }
  132. TEST(ContiguousIterator, VectorBool) {
  133. static_assert(!IsContiguousIterator<std::vector<bool>::iterator>::value,
  134. "Error: std::vector<bool>::iterator should not be considered "
  135. "a contiguous iterator.");
  136. static_assert(!IsContiguousIterator<std::vector<bool>::const_iterator>::value,
  137. "Error: std::vector<bool>::const_iterator should not be "
  138. "considered a contiguous iterator.");
  139. static_assert(
  140. !IsContiguousIterator<std::vector<bool>::reverse_iterator>::value,
  141. "Error: std::vector<bool>::reverse_iterator should not be considered a "
  142. "contiguous iterator.");
  143. static_assert(
  144. !IsContiguousIterator<std::vector<bool>::const_reverse_iterator>::value,
  145. "Error: std::vector<bool>::const_reverse_iterator should not be "
  146. "considered a contiguous iterator.");
  147. }
  148. TEST(ContiguousIterator, ArrayInt) {
  149. static_assert(IsContiguousIterator<std::array<int, 1>::iterator>::value,
  150. "Error: std::array<int, 1>::iterator should be considered a "
  151. "contiguous iterator.");
  152. static_assert(IsContiguousIterator<std::array<int, 1>::const_iterator>::value,
  153. "Error: std::array<int, 1>::const_iterator should be "
  154. "considered a contiguous iterator.");
  155. static_assert(
  156. !IsContiguousIterator<std::array<int, 1>::reverse_iterator>::value,
  157. "Error: std::array<int, 1>::reverse_iterator should not be considered "
  158. "a contiguous iterator.");
  159. static_assert(
  160. !IsContiguousIterator<std::array<int, 1>::const_reverse_iterator>::value,
  161. "Error: std::array<int, 1>::const_reverse_iterator should not be "
  162. "considered a contiguous iterator.");
  163. }
  164. TEST(ContiguousIterator, ArrayString) {
  165. static_assert(
  166. IsContiguousIterator<std::array<std::string, 1>::iterator>::value,
  167. "Error: std::array<std::string, 1>::iterator should be considered a "
  168. "contiguous iterator.");
  169. static_assert(
  170. IsContiguousIterator<std::array<std::string, 1>::const_iterator>::value,
  171. "Error: std::array<std::string, 1>::const_iterator should be considered "
  172. "a contiguous iterator.");
  173. static_assert(!IsContiguousIterator<
  174. std::array<std::string, 1>::reverse_iterator>::value,
  175. "Error: std::array<std::string, 1>::reverse_iterator should "
  176. "not be considered a contiguous iterator.");
  177. static_assert(!IsContiguousIterator<
  178. std::array<std::string, 1>::const_reverse_iterator>::value,
  179. "Error: std::array<std::string, 1>::const_reverse_iterator "
  180. "should not be considered a contiguous iterator.");
  181. }
  182. TEST(ContiguousIterator, String) {
  183. static_assert(IsContiguousIterator<std::string::iterator>::value,
  184. "Error: std::string:iterator should be considered a contiguous"
  185. "iterator.");
  186. static_assert(IsContiguousIterator<std::string::const_iterator>::value,
  187. "Error: std::string::const_iterator should be considered a "
  188. "contiguous iterator.");
  189. static_assert(!IsContiguousIterator<std::string::reverse_iterator>::value,
  190. "Error: std::string::reverse_iterator should not be considered "
  191. "a contiguous iterator.");
  192. static_assert(
  193. !IsContiguousIterator<std::string::const_reverse_iterator>::value,
  194. "Error: std::string::const_reverse_iterator should not be considered "
  195. "a contiguous iterator.");
  196. }
  197. TEST(ContiguousIterator, String16) {
  198. static_assert(IsContiguousIterator<std::u16string::iterator>::value,
  199. "Error: std::u16string:iterator should be considered a "
  200. "contiguous iterator.");
  201. static_assert(IsContiguousIterator<std::u16string::const_iterator>::value,
  202. "Error: std::u16string::const_iterator should be considered a "
  203. "contiguous iterator.");
  204. static_assert(!IsContiguousIterator<std::u16string::reverse_iterator>::value,
  205. "Error: std::u16string::reverse_iterator should not be "
  206. "considered a contiguous iterator.");
  207. static_assert(
  208. !IsContiguousIterator<std::u16string::const_reverse_iterator>::value,
  209. "Error: std::u16string::const_reverse_iterator should not be considered a"
  210. "contiguous iterator.");
  211. }
  212. TEST(ContiguousIterator, ValarrayInt) {
  213. static_assert(IsContiguousIterator<decltype(
  214. std::begin(std::declval<std::valarray<int>&>()))>::value,
  215. "Error: std::valarray<int>::iterator should be considered a "
  216. "contiguous iterator.");
  217. static_assert(
  218. IsContiguousIterator<decltype(
  219. std::begin(std::declval<const std::valarray<int>&>()))>::value,
  220. "Error: std::valarray<int>::const_iterator should be considered a "
  221. "contiguous iterator.");
  222. }
  223. TEST(ContiguousIterator, ValarrayString) {
  224. static_assert(IsContiguousIterator<decltype(std::begin(
  225. std::declval<std::valarray<std::string>&>()))>::value,
  226. "Error: std::valarray<std::string>::iterator should be "
  227. "considered a contiguous iterator.");
  228. static_assert(IsContiguousIterator<decltype(std::begin(
  229. std::declval<const std::valarray<std::string>&>()))>::value,
  230. "Error: std::valarray<std::string>::const_iterator should be "
  231. "considered a contiguous iterator.");
  232. }
  233. TEST(ContiguousIterator, StringPiece) {
  234. static_assert(
  235. IsContiguousIterator<base::StringPiece::const_iterator>::value,
  236. "Error: base::StringPiece::const_iterator should be considered a "
  237. "contiguous iterator.");
  238. static_assert(
  239. !IsContiguousIterator<base::StringPiece::const_reverse_iterator>::value,
  240. "Error: base::StringPiece::const_reverse_iterator should not be "
  241. "considered a contiguous iterator.");
  242. }
  243. TEST(ContiguousIterator, SpanInt) {
  244. static_assert(IsContiguousIterator<base::span<int>::iterator>::value,
  245. "Error: base::span<int>::iterator should be considered a "
  246. "contiguous iterator.");
  247. static_assert(!IsContiguousIterator<base::span<int>::reverse_iterator>::value,
  248. "Error: base::span<int>::reverse_iterator should not be "
  249. "considered a contiguous iterator.");
  250. }
  251. TEST(ContiguousIterator, SpanString) {
  252. static_assert(IsContiguousIterator<base::span<std::string>::iterator>::value,
  253. "Error: base::span<std::string>::iterator should be considered "
  254. "a contiguous iterator.");
  255. static_assert(
  256. !IsContiguousIterator<base::span<std::string>::reverse_iterator>::value,
  257. "Error: base::span<std::string>::reverse_iterator should not be "
  258. "considered a contiguous iterator.");
  259. }
  260. } // namespace base