1 //===- unittests/ADT/IListIteratorTest.cpp - ilist_iterator unit tests ----===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/ADT/simple_ilist.h" 11 #include "gtest/gtest.h" 12 13 using namespace llvm; 14 15 namespace { 16 17 struct Node : ilist_node<Node> {}; 18 19 TEST(IListIteratorTest, DefaultConstructor) { 20 simple_ilist<Node>::iterator I; 21 simple_ilist<Node>::reverse_iterator RI; 22 simple_ilist<Node>::const_iterator CI; 23 simple_ilist<Node>::const_reverse_iterator CRI; 24 EXPECT_EQ(nullptr, I.getNodePtr()); 25 EXPECT_EQ(nullptr, CI.getNodePtr()); 26 EXPECT_EQ(nullptr, RI.getNodePtr()); 27 EXPECT_EQ(nullptr, CRI.getNodePtr()); 28 EXPECT_EQ(I, I); 29 EXPECT_EQ(I, CI); 30 EXPECT_EQ(CI, I); 31 EXPECT_EQ(CI, CI); 32 EXPECT_EQ(RI, RI); 33 EXPECT_EQ(RI, CRI); 34 EXPECT_EQ(CRI, RI); 35 EXPECT_EQ(CRI, CRI); 36 EXPECT_EQ(I, RI.getReverse()); 37 EXPECT_EQ(RI, I.getReverse()); 38 } 39 40 TEST(IListIteratorTest, Empty) { 41 simple_ilist<Node> L; 42 43 // Check iterators of L. 44 EXPECT_EQ(L.begin(), L.end()); 45 EXPECT_EQ(L.rbegin(), L.rend()); 46 47 // Reverse of end should be rend (since the sentinel sits on both sides). 48 EXPECT_EQ(L.end(), L.rend().getReverse()); 49 EXPECT_EQ(L.rend(), L.end().getReverse()); 50 51 // Iterators shouldn't match default constructors. 52 simple_ilist<Node>::iterator I; 53 simple_ilist<Node>::reverse_iterator RI; 54 EXPECT_NE(I, L.begin()); 55 EXPECT_NE(I, L.end()); 56 EXPECT_NE(RI, L.rbegin()); 57 EXPECT_NE(RI, L.rend()); 58 } 59 60 TEST(IListIteratorTest, OneNodeList) { 61 simple_ilist<Node> L; 62 Node A; 63 L.insert(L.end(), A); 64 65 // Check address of reference. 66 EXPECT_EQ(&A, &*L.begin()); 67 EXPECT_EQ(&A, &*L.rbegin()); 68 69 // Check that the handle matches. 70 EXPECT_EQ(L.rbegin().getNodePtr(), L.begin().getNodePtr()); 71 72 // Check iteration. 73 EXPECT_EQ(L.end(), ++L.begin()); 74 EXPECT_EQ(L.begin(), --L.end()); 75 EXPECT_EQ(L.rend(), ++L.rbegin()); 76 EXPECT_EQ(L.rbegin(), --L.rend()); 77 78 // Check conversions. 79 EXPECT_EQ(L.rbegin(), L.begin().getReverse()); 80 EXPECT_EQ(L.begin(), L.rbegin().getReverse()); 81 } 82 83 TEST(IListIteratorTest, TwoNodeList) { 84 simple_ilist<Node> L; 85 Node A, B; 86 L.insert(L.end(), A); 87 L.insert(L.end(), B); 88 89 // Check order. 90 EXPECT_EQ(&A, &*L.begin()); 91 EXPECT_EQ(&B, &*++L.begin()); 92 EXPECT_EQ(L.end(), ++++L.begin()); 93 EXPECT_EQ(&B, &*L.rbegin()); 94 EXPECT_EQ(&A, &*++L.rbegin()); 95 EXPECT_EQ(L.rend(), ++++L.rbegin()); 96 97 // Check conversions. 98 EXPECT_EQ(++L.rbegin(), L.begin().getReverse()); 99 EXPECT_EQ(L.rbegin(), (++L.begin()).getReverse()); 100 EXPECT_EQ(++L.begin(), L.rbegin().getReverse()); 101 EXPECT_EQ(L.begin(), (++L.rbegin()).getReverse()); 102 } 103 104 TEST(IListIteratorTest, CheckEraseForward) { 105 simple_ilist<Node> L; 106 Node A, B; 107 L.insert(L.end(), A); 108 L.insert(L.end(), B); 109 110 // Erase nodes. 111 auto I = L.begin(); 112 EXPECT_EQ(&A, &*I); 113 L.remove(*I++); 114 EXPECT_EQ(&B, &*I); 115 L.remove(*I++); 116 EXPECT_EQ(L.end(), I); 117 } 118 119 TEST(IListIteratorTest, CheckEraseReverse) { 120 simple_ilist<Node> L; 121 Node A, B; 122 L.insert(L.end(), A); 123 L.insert(L.end(), B); 124 125 // Erase nodes. 126 auto RI = L.rbegin(); 127 EXPECT_EQ(&B, &*RI); 128 L.remove(*RI++); 129 EXPECT_EQ(&A, &*RI); 130 L.remove(*RI++); 131 EXPECT_EQ(L.rend(), RI); 132 } 133 134 TEST(IListIteratorTest, ReverseConstructor) { 135 simple_ilist<Node> L; 136 const simple_ilist<Node> &CL = L; 137 Node A, B; 138 L.insert(L.end(), A); 139 L.insert(L.end(), B); 140 141 // Save typing. 142 typedef simple_ilist<Node>::iterator iterator; 143 typedef simple_ilist<Node>::reverse_iterator reverse_iterator; 144 typedef simple_ilist<Node>::const_iterator const_iterator; 145 typedef simple_ilist<Node>::const_reverse_iterator const_reverse_iterator; 146 147 // Check conversion values. 148 EXPECT_EQ(L.begin(), iterator(L.rend())); 149 EXPECT_EQ(++L.begin(), iterator(++L.rbegin())); 150 EXPECT_EQ(L.end(), iterator(L.rbegin())); 151 EXPECT_EQ(L.rbegin(), reverse_iterator(L.end())); 152 EXPECT_EQ(++L.rbegin(), reverse_iterator(++L.begin())); 153 EXPECT_EQ(L.rend(), reverse_iterator(L.begin())); 154 155 // Check const iterator constructors. 156 EXPECT_EQ(CL.begin(), const_iterator(L.rend())); 157 EXPECT_EQ(CL.begin(), const_iterator(CL.rend())); 158 EXPECT_EQ(CL.rbegin(), const_reverse_iterator(L.end())); 159 EXPECT_EQ(CL.rbegin(), const_reverse_iterator(CL.end())); 160 161 // Confirm lack of implicit conversions. 162 static_assert(!std::is_convertible<iterator, reverse_iterator>::value, 163 "unexpected implicit conversion"); 164 static_assert(!std::is_convertible<reverse_iterator, iterator>::value, 165 "unexpected implicit conversion"); 166 static_assert( 167 !std::is_convertible<const_iterator, const_reverse_iterator>::value, 168 "unexpected implicit conversion"); 169 static_assert( 170 !std::is_convertible<const_reverse_iterator, const_iterator>::value, 171 "unexpected implicit conversion"); 172 } 173 174 } // end namespace 175
