values_unittest.cc 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369
  1. // Copyright 2017 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 "components/cbor/values.h"
  5. #include <string>
  6. #include <utility>
  7. #include "testing/gtest/include/gtest/gtest.h"
  8. namespace cbor {
  9. TEST(CBORValuesTest, TestNothrow) {
  10. static_assert(std::is_nothrow_move_constructible<Value>::value,
  11. "IsNothrowMoveConstructible");
  12. static_assert(std::is_nothrow_default_constructible<Value>::value,
  13. "IsNothrowDefaultConstructible");
  14. static_assert(std::is_nothrow_constructible<Value, std::string&&>::value,
  15. "IsNothrowMoveConstructibleFromString");
  16. static_assert(
  17. std::is_nothrow_constructible<Value, Value::BinaryValue&&>::value,
  18. "IsNothrowMoveConstructibleFromBytestring");
  19. static_assert(
  20. std::is_nothrow_constructible<Value, Value::ArrayValue&&>::value,
  21. "IsNothrowMoveConstructibleFromArray");
  22. static_assert(std::is_nothrow_move_assignable<Value>::value,
  23. "IsNothrowMoveAssignable");
  24. }
  25. // Test constructors
  26. TEST(CBORValuesTest, ConstructUnsigned) {
  27. Value value(37);
  28. ASSERT_EQ(Value::Type::UNSIGNED, value.type());
  29. EXPECT_EQ(37u, value.GetInteger());
  30. }
  31. TEST(CBORValuesTest, ConstructNegative) {
  32. Value value(-1);
  33. ASSERT_EQ(Value::Type::NEGATIVE, value.type());
  34. EXPECT_EQ(-1, value.GetInteger());
  35. }
  36. TEST(CBORValuesTest, ConstructStringFromConstCharPtr) {
  37. const char* str = "foobar";
  38. Value value(str);
  39. ASSERT_EQ(Value::Type::STRING, value.type());
  40. EXPECT_EQ("foobar", value.GetString());
  41. }
  42. TEST(CBORValuesTest, ConstructStringFromStdStringConstRef) {
  43. std::string str = "foobar";
  44. Value value(str);
  45. ASSERT_EQ(Value::Type::STRING, value.type());
  46. EXPECT_EQ("foobar", value.GetString());
  47. }
  48. TEST(CBORValuesTest, ConstructStringFromStdStringRefRef) {
  49. std::string str = "foobar";
  50. Value value(std::move(str));
  51. ASSERT_EQ(Value::Type::STRING, value.type());
  52. EXPECT_EQ("foobar", value.GetString());
  53. }
  54. TEST(CBORValuesTest, ConstructBytestring) {
  55. Value value(Value::BinaryValue({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
  56. ASSERT_EQ(Value::Type::BYTE_STRING, value.type());
  57. EXPECT_EQ(Value::BinaryValue({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}),
  58. value.GetBytestring());
  59. }
  60. TEST(CBORValuesTest, ConstructBytestringFromString) {
  61. Value value(Value("hello", Value::Type::BYTE_STRING));
  62. ASSERT_EQ(Value::Type::BYTE_STRING, value.type());
  63. EXPECT_EQ(Value::BinaryValue({'h', 'e', 'l', 'l', 'o'}),
  64. value.GetBytestring());
  65. EXPECT_EQ("hello", value.GetBytestringAsString());
  66. }
  67. TEST(CBORValuesTest, ConstructArray) {
  68. Value::ArrayValue array;
  69. array.emplace_back(Value("foo"));
  70. {
  71. Value value(array);
  72. ASSERT_EQ(Value::Type::ARRAY, value.type());
  73. ASSERT_EQ(1u, value.GetArray().size());
  74. ASSERT_EQ(Value::Type::STRING, value.GetArray()[0].type());
  75. EXPECT_EQ("foo", value.GetArray()[0].GetString());
  76. }
  77. array.back() = Value("bar");
  78. {
  79. Value value(std::move(array));
  80. ASSERT_EQ(Value::Type::ARRAY, value.type());
  81. ASSERT_EQ(1u, value.GetArray().size());
  82. ASSERT_EQ(Value::Type::STRING, value.GetArray()[0].type());
  83. EXPECT_EQ("bar", value.GetArray()[0].GetString());
  84. }
  85. }
  86. TEST(CBORValuesTest, ConstructMap) {
  87. Value::MapValue map;
  88. const Value key_foo("foo");
  89. map[Value("foo")] = Value("bar");
  90. {
  91. Value value(map);
  92. ASSERT_EQ(Value::Type::MAP, value.type());
  93. ASSERT_EQ(value.GetMap().count(key_foo), 1u);
  94. ASSERT_EQ(Value::Type::STRING, value.GetMap().find(key_foo)->second.type());
  95. EXPECT_EQ("bar", value.GetMap().find(key_foo)->second.GetString());
  96. }
  97. map[Value("foo")] = Value("baz");
  98. {
  99. Value value(std::move(map));
  100. ASSERT_EQ(Value::Type::MAP, value.type());
  101. ASSERT_EQ(value.GetMap().count(key_foo), 1u);
  102. ASSERT_EQ(Value::Type::STRING, value.GetMap().find(key_foo)->second.type());
  103. EXPECT_EQ("baz", value.GetMap().find(key_foo)->second.GetString());
  104. }
  105. }
  106. TEST(CBORValuesTest, ConstructSimpleValue) {
  107. Value false_value(Value::SimpleValue::FALSE_VALUE);
  108. ASSERT_EQ(Value::Type::SIMPLE_VALUE, false_value.type());
  109. EXPECT_EQ(Value::SimpleValue::FALSE_VALUE, false_value.GetSimpleValue());
  110. Value true_value(Value::SimpleValue::TRUE_VALUE);
  111. ASSERT_EQ(Value::Type::SIMPLE_VALUE, true_value.type());
  112. EXPECT_EQ(Value::SimpleValue::TRUE_VALUE, true_value.GetSimpleValue());
  113. Value null_value(Value::SimpleValue::NULL_VALUE);
  114. ASSERT_EQ(Value::Type::SIMPLE_VALUE, null_value.type());
  115. EXPECT_EQ(Value::SimpleValue::NULL_VALUE, null_value.GetSimpleValue());
  116. Value undefined_value(Value::SimpleValue::UNDEFINED);
  117. ASSERT_EQ(Value::Type::SIMPLE_VALUE, undefined_value.type());
  118. EXPECT_EQ(Value::SimpleValue::UNDEFINED, undefined_value.GetSimpleValue());
  119. }
  120. TEST(CBORValuesTest, ConstructSimpleBooleanValue) {
  121. Value true_value(true);
  122. ASSERT_EQ(Value::Type::SIMPLE_VALUE, true_value.type());
  123. EXPECT_TRUE(true_value.GetBool());
  124. Value false_value(false);
  125. ASSERT_EQ(Value::Type::SIMPLE_VALUE, false_value.type());
  126. EXPECT_FALSE(false_value.GetBool());
  127. }
  128. // Test copy constructors
  129. TEST(CBORValuesTest, CopyUnsigned) {
  130. Value value(74);
  131. Value copied_value(value.Clone());
  132. ASSERT_EQ(value.type(), copied_value.type());
  133. EXPECT_EQ(value.GetInteger(), copied_value.GetInteger());
  134. Value blank;
  135. blank = value.Clone();
  136. ASSERT_EQ(value.type(), blank.type());
  137. EXPECT_EQ(value.GetInteger(), blank.GetInteger());
  138. }
  139. TEST(CBORValuesTest, CopyNegativeInt) {
  140. Value value(-74);
  141. Value copied_value(value.Clone());
  142. ASSERT_EQ(value.type(), copied_value.type());
  143. EXPECT_EQ(value.GetInteger(), copied_value.GetInteger());
  144. Value blank;
  145. blank = value.Clone();
  146. ASSERT_EQ(value.type(), blank.type());
  147. EXPECT_EQ(value.GetInteger(), blank.GetInteger());
  148. }
  149. TEST(CBORValuesTest, CopyString) {
  150. Value value("foobar");
  151. Value copied_value(value.Clone());
  152. ASSERT_EQ(value.type(), copied_value.type());
  153. EXPECT_EQ(value.GetString(), copied_value.GetString());
  154. Value blank;
  155. blank = value.Clone();
  156. ASSERT_EQ(value.type(), blank.type());
  157. EXPECT_EQ(value.GetString(), blank.GetString());
  158. }
  159. TEST(CBORValuesTest, CopyBytestring) {
  160. Value value(Value::BinaryValue({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
  161. Value copied_value(value.Clone());
  162. ASSERT_EQ(value.type(), copied_value.type());
  163. EXPECT_EQ(value.GetBytestring(), copied_value.GetBytestring());
  164. Value blank;
  165. blank = value.Clone();
  166. ASSERT_EQ(value.type(), blank.type());
  167. EXPECT_EQ(value.GetBytestring(), blank.GetBytestring());
  168. }
  169. TEST(CBORValuesTest, CopyArray) {
  170. Value::ArrayValue array;
  171. array.emplace_back(123);
  172. Value value(std::move(array));
  173. Value copied_value(value.Clone());
  174. ASSERT_EQ(1u, copied_value.GetArray().size());
  175. ASSERT_TRUE(copied_value.GetArray()[0].is_unsigned());
  176. EXPECT_EQ(value.GetArray()[0].GetInteger(),
  177. copied_value.GetArray()[0].GetInteger());
  178. Value blank;
  179. blank = value.Clone();
  180. EXPECT_EQ(1u, blank.GetArray().size());
  181. }
  182. TEST(CBORValuesTest, CopyMap) {
  183. Value::MapValue map;
  184. Value key_a("a");
  185. map[Value("a")] = Value(123);
  186. Value value(std::move(map));
  187. Value copied_value(value.Clone());
  188. EXPECT_EQ(1u, copied_value.GetMap().size());
  189. ASSERT_EQ(value.GetMap().count(key_a), 1u);
  190. ASSERT_EQ(copied_value.GetMap().count(key_a), 1u);
  191. ASSERT_TRUE(copied_value.GetMap().find(key_a)->second.is_unsigned());
  192. EXPECT_EQ(value.GetMap().find(key_a)->second.GetInteger(),
  193. copied_value.GetMap().find(key_a)->second.GetInteger());
  194. Value blank;
  195. blank = value.Clone();
  196. EXPECT_EQ(1u, blank.GetMap().size());
  197. ASSERT_EQ(blank.GetMap().count(key_a), 1u);
  198. ASSERT_TRUE(blank.GetMap().find(key_a)->second.is_unsigned());
  199. EXPECT_EQ(value.GetMap().find(key_a)->second.GetInteger(),
  200. blank.GetMap().find(key_a)->second.GetInteger());
  201. }
  202. TEST(CBORValuesTest, CopySimpleValue) {
  203. Value value(Value::SimpleValue::TRUE_VALUE);
  204. Value copied_value(value.Clone());
  205. EXPECT_EQ(value.type(), copied_value.type());
  206. EXPECT_EQ(value.GetSimpleValue(), copied_value.GetSimpleValue());
  207. Value blank;
  208. blank = value.Clone();
  209. EXPECT_EQ(value.type(), blank.type());
  210. EXPECT_EQ(value.GetSimpleValue(), blank.GetSimpleValue());
  211. }
  212. // Test move constructors and move-assignment
  213. TEST(CBORValuesTest, MoveUnsigned) {
  214. Value value(74);
  215. Value moved_value(std::move(value));
  216. EXPECT_EQ(Value::Type::UNSIGNED, moved_value.type());
  217. EXPECT_EQ(74u, moved_value.GetInteger());
  218. Value blank;
  219. blank = Value(654);
  220. EXPECT_EQ(Value::Type::UNSIGNED, blank.type());
  221. EXPECT_EQ(654u, blank.GetInteger());
  222. }
  223. TEST(CBORValuesTest, MoveNegativeInteger) {
  224. Value value(-74);
  225. Value moved_value(std::move(value));
  226. EXPECT_EQ(Value::Type::NEGATIVE, moved_value.type());
  227. EXPECT_EQ(-74, moved_value.GetInteger());
  228. Value blank;
  229. blank = Value(-654);
  230. EXPECT_EQ(Value::Type::NEGATIVE, blank.type());
  231. EXPECT_EQ(-654, blank.GetInteger());
  232. }
  233. TEST(CBORValuesTest, MoveString) {
  234. Value value("foobar");
  235. Value moved_value(std::move(value));
  236. EXPECT_EQ(Value::Type::STRING, moved_value.type());
  237. EXPECT_EQ("foobar", moved_value.GetString());
  238. Value blank;
  239. blank = Value("foobar");
  240. EXPECT_EQ(Value::Type::STRING, blank.type());
  241. EXPECT_EQ("foobar", blank.GetString());
  242. }
  243. TEST(CBORValuesTest, MoveBytestring) {
  244. const Value::BinaryValue bytes({0xF, 0x0, 0x0, 0xB, 0xA, 0x2});
  245. Value value(bytes);
  246. Value moved_value(std::move(value));
  247. EXPECT_EQ(Value::Type::BYTE_STRING, moved_value.type());
  248. EXPECT_EQ(bytes, moved_value.GetBytestring());
  249. Value blank;
  250. blank = Value(bytes);
  251. EXPECT_EQ(Value::Type::BYTE_STRING, blank.type());
  252. EXPECT_EQ(bytes, blank.GetBytestring());
  253. }
  254. TEST(CBORValuesTest, MoveConstructMap) {
  255. Value::MapValue map;
  256. const Value key_a("a");
  257. map[Value("a")] = Value(123);
  258. Value value(std::move(map));
  259. Value moved_value(std::move(value));
  260. ASSERT_EQ(Value::Type::MAP, moved_value.type());
  261. ASSERT_EQ(moved_value.GetMap().count(key_a), 1u);
  262. ASSERT_TRUE(moved_value.GetMap().find(key_a)->second.is_unsigned());
  263. EXPECT_EQ(123u, moved_value.GetMap().find(key_a)->second.GetInteger());
  264. }
  265. TEST(CBORValuesTest, MoveAssignMap) {
  266. Value::MapValue map;
  267. const Value key_a("a");
  268. map[Value("a")] = Value(123);
  269. Value blank;
  270. blank = Value(std::move(map));
  271. ASSERT_TRUE(blank.is_map());
  272. ASSERT_EQ(blank.GetMap().count(key_a), 1u);
  273. ASSERT_TRUE(blank.GetMap().find(key_a)->second.is_unsigned());
  274. EXPECT_EQ(123u, blank.GetMap().find(key_a)->second.GetInteger());
  275. }
  276. TEST(CBORValuesTest, MoveArray) {
  277. Value::ArrayValue array;
  278. array.emplace_back(123);
  279. Value value(array);
  280. Value moved_value(std::move(value));
  281. EXPECT_EQ(Value::Type::ARRAY, moved_value.type());
  282. EXPECT_EQ(123u, moved_value.GetArray().back().GetInteger());
  283. Value blank;
  284. blank = Value(std::move(array));
  285. EXPECT_EQ(Value::Type::ARRAY, blank.type());
  286. EXPECT_EQ(123u, blank.GetArray().back().GetInteger());
  287. }
  288. TEST(CBORValuesTest, MoveSimpleValue) {
  289. Value value(Value::SimpleValue::UNDEFINED);
  290. Value moved_value(std::move(value));
  291. EXPECT_EQ(Value::Type::SIMPLE_VALUE, moved_value.type());
  292. EXPECT_EQ(Value::SimpleValue::UNDEFINED, moved_value.GetSimpleValue());
  293. Value blank;
  294. blank = Value(Value::SimpleValue::UNDEFINED);
  295. EXPECT_EQ(Value::Type::SIMPLE_VALUE, blank.type());
  296. EXPECT_EQ(Value::SimpleValue::UNDEFINED, blank.GetSimpleValue());
  297. }
  298. TEST(CBORValuesTest, SelfSwap) {
  299. Value test(1);
  300. std::swap(test, test);
  301. EXPECT_EQ(test.GetInteger(), 1u);
  302. }
  303. } // namespace cbor