Caffe2 - C++ API
A deep learning, cross platform ML framework
ordered_dict.cpp
1 #include <gtest/gtest.h>
2 
3 #include <test/cpp/api/support.h>
4 #include <torch/ordered_dict.h>
5 
6 template <typename T>
8 
9 TEST(OrderedDictTest, IsEmptyAfterDefaultConstruction) {
10  OrderedDict<int> dict;
11  ASSERT_EQ(dict.key_description(), "Key");
12  ASSERT_TRUE(dict.is_empty());
13  ASSERT_EQ(dict.size(), 0);
14 }
15 
16 TEST(OrderedDictTest, InsertAddsElementsWhenTheyAreYetNotPresent) {
17  OrderedDict<int> dict;
18  dict.insert("a", 1);
19  dict.insert("b", 2);
20  ASSERT_EQ(dict.size(), 2);
21 }
22 
23 TEST(OrderedDictTest, GetReturnsValuesWhenTheyArePresent) {
24  OrderedDict<int> dict;
25  dict.insert("a", 1);
26  dict.insert("b", 2);
27  ASSERT_EQ(dict["a"], 1);
28  ASSERT_EQ(dict["b"], 2);
29 }
30 
31 TEST(OrderedDictTest, GetThrowsWhenPassedKeysThatAreNotPresent) {
32  OrderedDict<int> dict;
33  dict.insert("a", 1);
34  dict.insert("b", 2);
35  ASSERT_THROWS_WITH(dict["foo"], "Key 'foo' is not defined");
36  ASSERT_THROWS_WITH(dict[""], "Key '' is not defined");
37 }
38 
39 TEST(OrderedDictTest, CanInitializeFromList) {
40  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
41  ASSERT_EQ(dict.size(), 2);
42  ASSERT_EQ(dict["a"], 1);
43  ASSERT_EQ(dict["b"], 2);
44 }
45 
46 TEST(OrderedDictTest, InsertThrowsWhenPassedElementsThatArePresent) {
47  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
48  ASSERT_THROWS_WITH(dict.insert("a", 1), "Key 'a' already defined");
49  ASSERT_THROWS_WITH(dict.insert("b", 1), "Key 'b' already defined");
50 }
51 
52 TEST(OrderedDictTest, FrontReturnsTheFirstItem) {
53  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
54  ASSERT_EQ(dict.front().key(), "a");
55  ASSERT_EQ(dict.front().value(), 1);
56 }
57 
58 TEST(OrderedDictTest, FrontThrowsWhenEmpty) {
59  OrderedDict<int> dict;
60  ASSERT_THROWS_WITH(dict.front(), "Called front() on an empty OrderedDict");
61 }
62 
63 TEST(OrderedDictTest, BackReturnsTheLastItem) {
64  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
65  ASSERT_EQ(dict.back().key(), "b");
66  ASSERT_EQ(dict.back().value(), 2);
67 }
68 
69 TEST(OrderedDictTest, BackThrowsWhenEmpty) {
70  OrderedDict<int> dict;
71  ASSERT_THROWS_WITH(dict.back(), "Called back() on an empty OrderedDict");
72 }
73 
74 TEST(OrderedDictTest, FindReturnsPointersToValuesWhenPresent) {
75  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
76  ASSERT_NE(dict.find("a"), nullptr);
77  ASSERT_EQ(*dict.find("a"), 1);
78  ASSERT_NE(dict.find("b"), nullptr);
79  ASSERT_EQ(*dict.find("b"), 2);
80 }
81 
82 TEST(OrderedDictTest, FindReturnsNullPointersWhenPasesdKeysThatAreNotPresent) {
83  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
84  ASSERT_EQ(dict.find("bar"), nullptr);
85  ASSERT_EQ(dict.find(""), nullptr);
86 }
87 
88 TEST(OrderedDictTest, SubscriptOperatorThrowsWhenPassedKeysThatAreNotPresent) {
89  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
90  ASSERT_EQ(dict["a"], 1);
91  ASSERT_EQ(dict["b"], 2);
92 }
93 
94 TEST(
95  OrderedDictTest,
96  SubscriptOperatorReturnsItemsPositionallyWhenPassedIntegers) {
97  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
98  ASSERT_EQ(dict[0].key(), "a");
99  ASSERT_EQ(dict[0].value(), 1);
100  ASSERT_EQ(dict[1].key(), "b");
101  ASSERT_EQ(dict[1].value(), 2);
102 }
103 
104 TEST(OrderedDictTest, SubscriptOperatorsThrowswhenPassedKeysThatAreNotPresent) {
105  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
106  ASSERT_THROWS_WITH(dict["foo"], "Key 'foo' is not defined");
107  ASSERT_THROWS_WITH(dict[""], "Key '' is not defined");
108 }
109 
110 TEST(OrderedDictTest, UpdateInsertsAllItemsFromAnotherOrderedDict) {
111  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
112  OrderedDict<int> dict2 = {{"c", 3}};
113  dict2.update(dict);
114  ASSERT_EQ(dict2.size(), 3);
115  ASSERT_NE(dict2.find("a"), nullptr);
116  ASSERT_NE(dict2.find("b"), nullptr);
117  ASSERT_NE(dict2.find("c"), nullptr);
118 }
119 
120 TEST(OrderedDictTest, UpdateAlsoChecksForDuplicates) {
121  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
122  OrderedDict<int> dict2 = {{"a", 1}};
123  ASSERT_THROWS_WITH(dict2.update(dict), "Key 'a' already defined");
124 }
125 
126 TEST(OrderedDictTest, CanIterateItems) {
127  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
128  auto iterator = dict.begin();
129  ASSERT_NE(iterator, dict.end());
130  ASSERT_EQ(iterator->key(), "a");
131  ASSERT_EQ(iterator->value(), 1);
132  ++iterator;
133  ASSERT_NE(iterator, dict.end());
134  ASSERT_EQ(iterator->key(), "b");
135  ASSERT_EQ(iterator->value(), 2);
136  ++iterator;
137  ASSERT_EQ(iterator, dict.end());
138 }
139 
140 TEST(OrderedDictTest, ClearMakesTheDictEmpty) {
141  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
142  ASSERT_FALSE(dict.is_empty());
143  dict.clear();
144  ASSERT_TRUE(dict.is_empty());
145 }
146 
147 TEST(OrderedDictTest, CanCopyConstruct) {
148  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
149  OrderedDict<int> copy = dict;
150  ASSERT_EQ(copy.size(), 2);
151  ASSERT_EQ(*copy[0], 1);
152  ASSERT_EQ(*copy[1], 2);
153 }
154 
155 TEST(OrderedDictTest, CanCopyAssign) {
156  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
157  OrderedDict<int> copy = {{"c", 1}};
158  ASSERT_NE(copy.find("c"), nullptr);
159  copy = dict;
160  ASSERT_EQ(copy.size(), 2);
161  ASSERT_EQ(*copy[0], 1);
162  ASSERT_EQ(*copy[1], 2);
163  ASSERT_EQ(copy.find("c"), nullptr);
164 }
165 
166 TEST(OrderedDictTest, CanMoveConstruct) {
167  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
168  OrderedDict<int> copy = std::move(dict);
169  ASSERT_EQ(copy.size(), 2);
170  ASSERT_EQ(*copy[0], 1);
171  ASSERT_EQ(*copy[1], 2);
172 }
173 
174 TEST(OrderedDictTest, CanMoveAssign) {
175  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
176  OrderedDict<int> copy = {{"c", 1}};
177  ASSERT_NE(copy.find("c"), nullptr);
178  copy = std::move(dict);
179  ASSERT_EQ(copy.size(), 2);
180  ASSERT_EQ(*copy[0], 1);
181  ASSERT_EQ(*copy[1], 2);
182  ASSERT_EQ(copy.find("c"), nullptr);
183 }
184 
185 TEST(OrderedDictTest, CanInsertWithBraces) {
187  dict.insert("a", {1, 2});
188  ASSERT_FALSE(dict.is_empty());
189  ASSERT_EQ(dict["a"].first, 1);
190  ASSERT_EQ(dict["a"].second, 2);
191 }
192 
193 TEST(OrderedDictTest, ErrorMessagesIncludeTheKeyDescription) {
194  OrderedDict<int> dict("Penguin");
195  ASSERT_EQ(dict.key_description(), "Penguin");
196  dict.insert("a", 1);
197  ASSERT_FALSE(dict.is_empty());
198  ASSERT_THROWS_WITH(dict["b"], "Penguin 'b' is not defined");
199  ASSERT_THROWS_WITH(dict.insert("a", 1), "Penguin 'a' already defined");
200 }
201 
202 TEST(OrderedDictTest, KeysReturnsAllKeys) {
203  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
204  ASSERT_EQ(dict.keys(), std::vector<std::string>({"a", "b"}));
205 }
206 
207 TEST(OrderedDictTest, ValuesReturnsAllValues) {
208  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
209  ASSERT_EQ(dict.values(), std::vector<int>({1, 2}));
210 }
211 
212 TEST(OrderedDictTest, ItemsReturnsAllItems) {
213  OrderedDict<int> dict = {{"a", 1}, {"b", 2}};
214  std::vector<OrderedDict<int>::Item> items = dict.items();
215  ASSERT_EQ(items.size(), 2);
216  ASSERT_EQ(items[0].key(), "a");
217  ASSERT_EQ(items[0].value(), 1);
218  ASSERT_EQ(items[1].key(), "b");
219  ASSERT_EQ(items[1].value(), 2);
220 }
::std::vector< Value > values() const
Returns a newly allocated vector and copies all values from this OrderedDict into the vector...
Definition: ordered_dict.h:451
size_t size() const noexcept
Returns the number of items currently stored in the OrderedDict.
Definition: ordered_dict.h:419
Iterator begin()
Returns an iterator to the first item in the OrderedDict.
Definition: ordered_dict.h:278
Iterator end()
Returns an iterator one past the last item in the OrderedDict.
Definition: ordered_dict.h:289
Value & insert(K &&key, V &&value)
Inserts a new (key, value) pair into the OrderedDict.
Definition: ordered_dict.h:357
Value * find(const Key &key) noexcept
Returns a pointer to the value associated with the given key, or a nullptr if no such key is stored i...
Definition: ordered_dict.h:390
bool is_empty() const noexcept
Returns true if the OrderedDict contains no elements.
Definition: ordered_dict.h:424
void update(OrderedDict &&other)
Inserts all items from other into this OrderedDict.
Definition: ordered_dict.h:372
const std::string & key_description() const noexcept
Returns the key description string the OrderedDict was constructed with.
Definition: ordered_dict.h:429
Item & back()
Returns the very last item in the OrderedDict and throws an exception if it is empty.
Definition: ordered_dict.h:313
const std::vector< Item > & items() const noexcept
Returns the items stored in the OrderedDict.
Definition: ordered_dict.h:436
::std::vector< Key > keys() const
Returns a newly allocated vector and copies all keys from this OrderedDict into the vector...
Definition: ordered_dict.h:441
void clear()
Removes all items from this OrderedDict.
Definition: ordered_dict.h:413
An ordered dictionary implementation, akin to Python&#39;s OrderedDict.
Definition: ordered_dict.h:16
Item & front()
Returns the very first item in the OrderedDict and throws an exception if it is empty.
Definition: ordered_dict.h:300