values_unittest.cc 83 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526
  1. // Copyright (c) 2012 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/values.h"
  5. #include <stddef.h>
  6. #include <algorithm>
  7. #include <functional>
  8. #include <iterator>
  9. #include <limits>
  10. #include <memory>
  11. #include <string>
  12. #include <type_traits>
  13. #include <utility>
  14. #include <vector>
  15. #include "base/as_const.h"
  16. #include "base/bits.h"
  17. #include "base/containers/adapters.h"
  18. #include "base/containers/contains.h"
  19. #include "base/strings/string_piece.h"
  20. #include "base/strings/utf_string_conversions.h"
  21. #include "base/test/gtest_util.h"
  22. #include "build/build_config.h"
  23. #include "testing/gmock/include/gmock/gmock.h"
  24. #include "testing/gtest/include/gtest/gtest.h"
  25. #if BUILDFLAG(ENABLE_BASE_TRACING)
  26. #include "third_party/abseil-cpp/absl/types/optional.h"
  27. #include "third_party/perfetto/include/perfetto/test/traced_value_test_support.h" // no-presubmit-check nogncheck
  28. #endif // BUILDFLAG(ENABLE_BASE_TRACING)
  29. namespace base {
  30. #ifdef NDEBUG
  31. // `Value` should have a (relatively) small size to avoid creating excess
  32. // overhead, e.g. for lists of values that are all ints.
  33. //
  34. // This test is limited to NDEBUG builds, since some containers may require
  35. // extra storage for supporting debug checks for things like iterators.
  36. TEST(ValuesTest, SizeOfValue) {
  37. #if BUILDFLAG(IS_WIN)
  38. // On Windows, clang-cl does not support `[[no_unique_address]]` (see
  39. // https://github.com/llvm/llvm-project/issues/49358). `base::Value::Dict` has
  40. // a `base::flat_tree` which relies on this attribute to avoid wasting space
  41. // when the comparator is stateless. Unfortunately, this means
  42. // `base::Value::Dict` ends up taking 4 machine words instead of 3. An
  43. // additional word is used by absl::variant for the type index.
  44. constexpr size_t kExpectedSize = 5 * sizeof(void*);
  45. #elif defined(__GLIBCXX__)
  46. // libstdc++ std::string takes already 4 machine words, so the absl::variant
  47. // takes 5
  48. constexpr size_t kExpectedSize = 5 * sizeof(void*);
  49. #else // !BUILDFLAG(IS_WIN) && !defined(__GLIBCXX__)
  50. // libc++'s std::string and std::vector both take 3 machine words. An
  51. // additional word is used by absl::variant for the type index.
  52. constexpr size_t kExpectedSize = 4 * sizeof(void*);
  53. #endif // BUILDFLAG(IS_WIN)
  54. // Use std::integral_constant so the compiler error message includes the
  55. // evaluated size. In future versions of clang, it should be possible to
  56. // simplify this to an equality comparison (i.e. newer clangs print out
  57. // "comparison reduces to '(1 == 2)'").
  58. static_assert(std::is_same_v<std::integral_constant<size_t, sizeof(Value)>,
  59. std::integral_constant<size_t, kExpectedSize>>,
  60. "base::Value has an unexpected size!");
  61. }
  62. #endif
  63. TEST(ValuesTest, TestNothrow) {
  64. static_assert(std::is_nothrow_move_constructible<Value>::value,
  65. "IsNothrowMoveConstructible");
  66. static_assert(std::is_nothrow_default_constructible<Value>::value,
  67. "IsNothrowDefaultConstructible");
  68. static_assert(std::is_nothrow_constructible<Value, std::string&&>::value,
  69. "IsNothrowMoveConstructibleFromString");
  70. static_assert(
  71. std::is_nothrow_constructible<Value, Value::BlobStorage&&>::value,
  72. "IsNothrowMoveConstructibleFromBlob");
  73. static_assert(std::is_nothrow_move_assignable<Value>::value,
  74. "IsNothrowMoveAssignable");
  75. }
  76. TEST(ValuesTest, EmptyValue) {
  77. Value value;
  78. EXPECT_EQ(Value::Type::NONE, value.type());
  79. EXPECT_EQ(absl::nullopt, value.GetIfBool());
  80. EXPECT_EQ(absl::nullopt, value.GetIfInt());
  81. EXPECT_EQ(absl::nullopt, value.GetIfDouble());
  82. EXPECT_EQ(nullptr, value.GetIfString());
  83. EXPECT_EQ(nullptr, value.GetIfBlob());
  84. }
  85. // Group of tests for the value constructors.
  86. TEST(ValuesTest, ConstructBool) {
  87. Value true_value(true);
  88. EXPECT_EQ(Value::Type::BOOLEAN, true_value.type());
  89. EXPECT_THAT(true_value.GetIfBool(), testing::Optional(true));
  90. EXPECT_TRUE(true_value.GetBool());
  91. Value false_value(false);
  92. EXPECT_EQ(Value::Type::BOOLEAN, false_value.type());
  93. EXPECT_THAT(false_value.GetIfBool(), testing::Optional(false));
  94. EXPECT_FALSE(false_value.GetBool());
  95. }
  96. TEST(ValuesTest, ConstructFromPtrs) {
  97. static_assert(!std::is_constructible<Value, int*>::value, "");
  98. static_assert(!std::is_constructible<Value, const int*>::value, "");
  99. static_assert(!std::is_constructible<Value, wchar_t*>::value, "");
  100. static_assert(!std::is_constructible<Value, const wchar_t*>::value, "");
  101. static_assert(std::is_constructible<Value, char*>::value, "");
  102. static_assert(std::is_constructible<Value, const char*>::value, "");
  103. static_assert(std::is_constructible<Value, char16_t*>::value, "");
  104. static_assert(std::is_constructible<Value, const char16_t*>::value, "");
  105. }
  106. TEST(ValuesTest, ConstructInt) {
  107. Value value(-37);
  108. EXPECT_EQ(Value::Type::INTEGER, value.type());
  109. EXPECT_THAT(value.GetIfInt(), testing::Optional(-37));
  110. EXPECT_EQ(-37, value.GetInt());
  111. EXPECT_THAT(value.GetIfDouble(), testing::Optional(-37.0));
  112. EXPECT_EQ(-37.0, value.GetDouble());
  113. }
  114. TEST(ValuesTest, ConstructDouble) {
  115. Value value(-4.655);
  116. EXPECT_EQ(Value::Type::DOUBLE, value.type());
  117. EXPECT_THAT(value.GetIfDouble(), testing::Optional(-4.655));
  118. EXPECT_EQ(-4.655, value.GetDouble());
  119. }
  120. TEST(ValuesTest, ConstructStringFromConstCharPtr) {
  121. const char* str = "foobar";
  122. Value value(str);
  123. EXPECT_EQ(Value::Type::STRING, value.type());
  124. EXPECT_THAT(value.GetIfString(), testing::Pointee(std::string("foobar")));
  125. EXPECT_EQ("foobar", value.GetString());
  126. }
  127. TEST(ValuesTest, ConstructStringFromStringPiece) {
  128. std::string str = "foobar";
  129. Value value{StringPiece(str)};
  130. EXPECT_EQ(Value::Type::STRING, value.type());
  131. EXPECT_THAT(value.GetIfString(), testing::Pointee(std::string("foobar")));
  132. EXPECT_EQ("foobar", value.GetString());
  133. }
  134. TEST(ValuesTest, ConstructStringFromStdStringRRef) {
  135. std::string str = "foobar";
  136. Value value(std::move(str));
  137. EXPECT_EQ(Value::Type::STRING, value.type());
  138. EXPECT_THAT(value.GetIfString(), testing::Pointee(std::string("foobar")));
  139. EXPECT_EQ("foobar", value.GetString());
  140. }
  141. TEST(ValuesTest, ConstructStringFromConstChar16Ptr) {
  142. std::u16string str = u"foobar";
  143. Value value(str.c_str());
  144. EXPECT_EQ(Value::Type::STRING, value.type());
  145. EXPECT_THAT(value.GetIfString(), testing::Pointee(std::string("foobar")));
  146. EXPECT_EQ("foobar", value.GetString());
  147. }
  148. TEST(ValuesTest, ConstructStringFromStringPiece16) {
  149. std::u16string str = u"foobar";
  150. Value value{StringPiece16(str)};
  151. EXPECT_EQ(Value::Type::STRING, value.type());
  152. EXPECT_THAT(value.GetIfString(), testing::Pointee(std::string("foobar")));
  153. EXPECT_EQ("foobar", value.GetString());
  154. }
  155. TEST(ValuesTest, ConstructBinary) {
  156. Value::BlobStorage blob = {0xF, 0x0, 0x0, 0xB, 0xA, 0x2};
  157. Value value(blob);
  158. EXPECT_EQ(Value::Type::BINARY, value.type());
  159. EXPECT_THAT(value.GetIfBlob(), testing::Pointee(blob));
  160. EXPECT_EQ(blob, value.GetBlob());
  161. }
  162. TEST(ValuesTest, ConstructDict) {
  163. DictionaryValue value;
  164. EXPECT_EQ(Value::Type::DICTIONARY, value.type());
  165. }
  166. TEST(ValuesTest, ConstructDictFromValueDict) {
  167. Value::Dict dict;
  168. dict.Set("foo", "bar");
  169. {
  170. Value value(dict.Clone());
  171. EXPECT_EQ(Value::Type::DICT, value.type());
  172. EXPECT_TRUE(value.GetIfDict());
  173. EXPECT_TRUE(value.GetDict().FindString("foo"));
  174. EXPECT_EQ("bar", *value.GetDict().FindString("foo"));
  175. }
  176. dict.Set("foo", "baz");
  177. {
  178. Value value(std::move(dict));
  179. EXPECT_EQ(Value::Type::DICT, value.type());
  180. EXPECT_TRUE(value.GetIfDict());
  181. EXPECT_TRUE(value.GetDict().FindString("foo"));
  182. EXPECT_EQ("baz", *value.GetDict().FindString("foo"));
  183. }
  184. }
  185. TEST(ValuesTest, ConstructList) {
  186. ListValue value;
  187. EXPECT_EQ(Value::Type::LIST, value.type());
  188. }
  189. TEST(ValuesTest, UseTestingEachOnValueList) {
  190. Value::List list;
  191. list.Append(true);
  192. list.Append(true);
  193. // This will only work if `Value::List::value_type` is defined.
  194. EXPECT_THAT(list, testing::Each(testing::ResultOf(
  195. [](const Value& value) { return value.GetBool(); },
  196. testing::Eq(true))));
  197. }
  198. TEST(ValuesTest, ConstructListFromValueList) {
  199. Value::List list;
  200. list.Append("foo");
  201. {
  202. Value value(list.Clone());
  203. EXPECT_EQ(Value::Type::LIST, value.type());
  204. EXPECT_EQ(1u, value.GetList().size());
  205. EXPECT_EQ(Value::Type::STRING, value.GetList()[0].type());
  206. EXPECT_EQ("foo", value.GetList()[0].GetString());
  207. }
  208. list.back() = base::Value("bar");
  209. {
  210. Value value(std::move(list));
  211. EXPECT_EQ(Value::Type::LIST, value.type());
  212. EXPECT_EQ(1u, value.GetList().size());
  213. EXPECT_EQ(Value::Type::STRING, value.GetList()[0].type());
  214. EXPECT_EQ("bar", value.GetList()[0].GetString());
  215. }
  216. }
  217. TEST(ValuesTest, HardenTests) {
  218. Value value;
  219. ASSERT_EQ(value.type(), Value::Type::NONE);
  220. EXPECT_DEATH_IF_SUPPORTED(value.GetBool(), "");
  221. EXPECT_DEATH_IF_SUPPORTED(value.GetInt(), "");
  222. EXPECT_DEATH_IF_SUPPORTED(value.GetDouble(), "");
  223. EXPECT_DEATH_IF_SUPPORTED(value.GetString(), "");
  224. EXPECT_DEATH_IF_SUPPORTED(value.GetBlob(), "");
  225. EXPECT_DEATH_IF_SUPPORTED(value.DictItems(), "");
  226. EXPECT_DEATH_IF_SUPPORTED(value.GetListDeprecated(), "");
  227. }
  228. // Group of tests for the copy constructors and copy-assigmnent. For equality
  229. // checks comparisons of the interesting fields are done instead of relying on
  230. // Equals being correct.
  231. TEST(ValuesTest, CopyBool) {
  232. Value true_value(true);
  233. Value copied_true_value(true_value.Clone());
  234. EXPECT_EQ(true_value.type(), copied_true_value.type());
  235. EXPECT_EQ(true_value.GetBool(), copied_true_value.GetBool());
  236. Value false_value(false);
  237. Value copied_false_value(false_value.Clone());
  238. EXPECT_EQ(false_value.type(), copied_false_value.type());
  239. EXPECT_EQ(false_value.GetBool(), copied_false_value.GetBool());
  240. Value blank;
  241. blank = true_value.Clone();
  242. EXPECT_EQ(true_value.type(), blank.type());
  243. EXPECT_EQ(true_value.GetBool(), blank.GetBool());
  244. blank = false_value.Clone();
  245. EXPECT_EQ(false_value.type(), blank.type());
  246. EXPECT_EQ(false_value.GetBool(), blank.GetBool());
  247. }
  248. TEST(ValuesTest, CopyInt) {
  249. Value value(74);
  250. Value copied_value(value.Clone());
  251. EXPECT_EQ(value.type(), copied_value.type());
  252. EXPECT_EQ(value.GetInt(), copied_value.GetInt());
  253. Value blank;
  254. blank = value.Clone();
  255. EXPECT_EQ(value.type(), blank.type());
  256. EXPECT_EQ(value.GetInt(), blank.GetInt());
  257. }
  258. TEST(ValuesTest, CopyDouble) {
  259. Value value(74.896);
  260. Value copied_value(value.Clone());
  261. EXPECT_EQ(value.type(), copied_value.type());
  262. EXPECT_EQ(value.GetDouble(), copied_value.GetDouble());
  263. Value blank;
  264. blank = value.Clone();
  265. EXPECT_EQ(value.type(), blank.type());
  266. EXPECT_EQ(value.GetDouble(), blank.GetDouble());
  267. }
  268. TEST(ValuesTest, CopyString) {
  269. Value value("foobar");
  270. Value copied_value(value.Clone());
  271. EXPECT_EQ(value.type(), copied_value.type());
  272. EXPECT_EQ(value.GetString(), copied_value.GetString());
  273. Value blank;
  274. blank = value.Clone();
  275. EXPECT_EQ(value.type(), blank.type());
  276. EXPECT_EQ(value.GetString(), blank.GetString());
  277. }
  278. TEST(ValuesTest, CopyBinary) {
  279. Value value(Value::BlobStorage({0xF, 0x0, 0x0, 0xB, 0xA, 0x2}));
  280. Value copied_value(value.Clone());
  281. EXPECT_EQ(value.type(), copied_value.type());
  282. EXPECT_EQ(value.GetBlob(), copied_value.GetBlob());
  283. Value blank;
  284. blank = value.Clone();
  285. EXPECT_EQ(value.type(), blank.type());
  286. EXPECT_EQ(value.GetBlob(), blank.GetBlob());
  287. }
  288. TEST(ValuesTest, CopyDictionary) {
  289. Value::Dict dict;
  290. dict.Set("Int", 123);
  291. Value value(std::move(dict));
  292. Value copied_value(value.Clone());
  293. EXPECT_EQ(value, copied_value);
  294. Value blank;
  295. blank = value.Clone();
  296. EXPECT_EQ(value, blank);
  297. }
  298. TEST(ValuesTest, CopyList) {
  299. Value::List list;
  300. list.Append(123);
  301. Value value(std::move(list));
  302. Value copied_value(value.Clone());
  303. EXPECT_EQ(value, copied_value);
  304. Value blank;
  305. blank = value.Clone();
  306. EXPECT_EQ(value, blank);
  307. }
  308. // Group of tests for the move constructors and move-assigmnent.
  309. TEST(ValuesTest, MoveBool) {
  310. Value true_value(true);
  311. Value moved_true_value(std::move(true_value));
  312. EXPECT_EQ(Value::Type::BOOLEAN, moved_true_value.type());
  313. EXPECT_TRUE(moved_true_value.GetBool());
  314. Value false_value(false);
  315. Value moved_false_value(std::move(false_value));
  316. EXPECT_EQ(Value::Type::BOOLEAN, moved_false_value.type());
  317. EXPECT_FALSE(moved_false_value.GetBool());
  318. Value blank;
  319. blank = Value(true);
  320. EXPECT_EQ(Value::Type::BOOLEAN, blank.type());
  321. EXPECT_TRUE(blank.GetBool());
  322. blank = Value(false);
  323. EXPECT_EQ(Value::Type::BOOLEAN, blank.type());
  324. EXPECT_FALSE(blank.GetBool());
  325. }
  326. TEST(ValuesTest, MoveInt) {
  327. Value value(74);
  328. Value moved_value(std::move(value));
  329. EXPECT_EQ(Value::Type::INTEGER, moved_value.type());
  330. EXPECT_EQ(74, moved_value.GetInt());
  331. Value blank;
  332. blank = Value(47);
  333. EXPECT_EQ(Value::Type::INTEGER, blank.type());
  334. EXPECT_EQ(47, blank.GetInt());
  335. }
  336. TEST(ValuesTest, MoveDouble) {
  337. Value value(74.896);
  338. Value moved_value(std::move(value));
  339. EXPECT_EQ(Value::Type::DOUBLE, moved_value.type());
  340. EXPECT_EQ(74.896, moved_value.GetDouble());
  341. Value blank;
  342. blank = Value(654.38);
  343. EXPECT_EQ(Value::Type::DOUBLE, blank.type());
  344. EXPECT_EQ(654.38, blank.GetDouble());
  345. }
  346. TEST(ValuesTest, MoveString) {
  347. Value value("foobar");
  348. Value moved_value(std::move(value));
  349. EXPECT_EQ(Value::Type::STRING, moved_value.type());
  350. EXPECT_EQ("foobar", moved_value.GetString());
  351. Value blank;
  352. blank = Value("foobar");
  353. EXPECT_EQ(Value::Type::STRING, blank.type());
  354. EXPECT_EQ("foobar", blank.GetString());
  355. }
  356. TEST(ValuesTest, MoveBinary) {
  357. const Value::BlobStorage buffer = {0xF, 0x0, 0x0, 0xB, 0xA, 0x2};
  358. Value value(buffer);
  359. Value moved_value(std::move(value));
  360. EXPECT_EQ(Value::Type::BINARY, moved_value.type());
  361. EXPECT_EQ(buffer, moved_value.GetBlob());
  362. Value blank;
  363. blank = Value(buffer);
  364. EXPECT_EQ(Value::Type::BINARY, blank.type());
  365. EXPECT_EQ(buffer, blank.GetBlob());
  366. }
  367. TEST(ValuesTest, MoveConstructDictionary) {
  368. Value::Dict dict;
  369. dict.Set("Int", 123);
  370. Value value(std::move(dict));
  371. Value moved_value(std::move(value));
  372. EXPECT_EQ(Value::Type::DICTIONARY, moved_value.type());
  373. EXPECT_EQ(123, moved_value.FindKey("Int")->GetInt());
  374. }
  375. TEST(ValuesTest, MoveAssignDictionary) {
  376. Value::Dict dict;
  377. dict.Set("Int", 123);
  378. Value blank;
  379. blank = Value(std::move(dict));
  380. EXPECT_EQ(Value::Type::DICTIONARY, blank.type());
  381. EXPECT_EQ(123, blank.FindKey("Int")->GetInt());
  382. }
  383. TEST(ValuesTest, ConstructDictWithIterators) {
  384. std::vector<std::pair<std::string, Value>> values;
  385. values.emplace_back(std::make_pair("Int", 123));
  386. Value blank;
  387. blank = Value(Value::Dict(std::make_move_iterator(values.begin()),
  388. std::make_move_iterator(values.end())));
  389. EXPECT_EQ(Value::Type::DICTIONARY, blank.type());
  390. EXPECT_EQ(123, blank.FindKey("Int")->GetInt());
  391. }
  392. TEST(ValuesTest, MoveList) {
  393. Value::List list;
  394. list.Append(123);
  395. Value value(list.Clone());
  396. Value moved_value(std::move(value));
  397. EXPECT_EQ(Value::Type::LIST, moved_value.type());
  398. EXPECT_EQ(123, moved_value.GetListDeprecated().back().GetInt());
  399. Value blank;
  400. blank = Value(std::move(list));
  401. EXPECT_EQ(Value::Type::LIST, blank.type());
  402. EXPECT_EQ(123, blank.GetListDeprecated().back().GetInt());
  403. }
  404. TEST(ValuesTest, Append) {
  405. ListValue value;
  406. value.Append(true);
  407. EXPECT_TRUE(value.GetListDeprecated().back().is_bool());
  408. value.Append(123);
  409. EXPECT_TRUE(value.GetListDeprecated().back().is_int());
  410. value.Append(3.14);
  411. EXPECT_TRUE(value.GetListDeprecated().back().is_double());
  412. std::string str = "foo";
  413. value.Append(str.c_str());
  414. EXPECT_TRUE(value.GetListDeprecated().back().is_string());
  415. value.Append(StringPiece(str));
  416. EXPECT_TRUE(value.GetListDeprecated().back().is_string());
  417. value.Append(std::move(str));
  418. EXPECT_TRUE(value.GetListDeprecated().back().is_string());
  419. std::u16string str16 = u"bar";
  420. value.GetList().Append(str16.c_str());
  421. EXPECT_TRUE(value.GetList().back().is_string());
  422. value.Append(base::StringPiece16(str16));
  423. EXPECT_TRUE(value.GetListDeprecated().back().is_string());
  424. value.Append(Value());
  425. EXPECT_TRUE(value.GetListDeprecated().back().is_none());
  426. value.Append(Value(Value::Type::DICTIONARY));
  427. EXPECT_TRUE(value.GetListDeprecated().back().is_dict());
  428. value.Append(Value(Value::Type::LIST));
  429. EXPECT_TRUE(value.GetListDeprecated().back().is_list());
  430. }
  431. TEST(ValuesTest, ListInsert) {
  432. Value::List list;
  433. const Value::List& const_list = list;
  434. auto iter = list.Insert(list.end(), Value(true));
  435. EXPECT_TRUE(list.begin() == iter);
  436. EXPECT_EQ(*iter, true);
  437. iter = list.Insert(const_list.begin(), Value(123));
  438. EXPECT_TRUE(const_list.begin() == iter);
  439. EXPECT_EQ(*iter, 123);
  440. iter = list.Insert(list.begin() + 1, Value("Hello world!"));
  441. EXPECT_TRUE(list.begin() + 1 == iter);
  442. EXPECT_EQ(*iter, "Hello world!");
  443. }
  444. // Test all three behaviors of EnsureDict() (Create a new dict where no
  445. // matchining values exist, return an existing dict, create a dict overwriting
  446. // a value of another type).
  447. TEST(ValuesTest, DictEnsureDict) {
  448. Value::Dict root;
  449. // This call should create a new nested dictionary.
  450. Value::Dict* foo_dict = root.EnsureDict("foo");
  451. EXPECT_TRUE(foo_dict->empty());
  452. foo_dict->Set("a", "b");
  453. // This call should retrieve the dictionary created above, rather than
  454. // creating a new one.
  455. std::string* a_string = root.EnsureDict("foo")->FindString("a");
  456. ASSERT_NE(nullptr, a_string);
  457. EXPECT_EQ(*a_string, "b");
  458. // Use EnsureDict() to overwrite an existing non-dictionary value.
  459. root.Set("bar", 3);
  460. Value::Dict* bar_dict = root.EnsureDict("bar");
  461. EXPECT_TRUE(bar_dict->empty());
  462. bar_dict->Set("b", "c");
  463. // Test that the above call created a "bar" entry.
  464. bar_dict = root.FindDict("bar");
  465. ASSERT_NE(nullptr, bar_dict);
  466. std::string* b_string = bar_dict->FindString("b");
  467. ASSERT_NE(nullptr, b_string);
  468. EXPECT_EQ(*b_string, "c");
  469. }
  470. // Test all three behaviors of EnsureList() (Create a new list where no
  471. // matchining value exists, return an existing list, create a list overwriting
  472. // a value of another type).
  473. TEST(ValuesTest, DictEnsureList) {
  474. Value::Dict root;
  475. // This call should create a new list.
  476. Value::List* foo_list = root.EnsureList("foo");
  477. EXPECT_TRUE(foo_list->empty());
  478. foo_list->Append("a");
  479. // This call should retrieve the list created above, rather than creating a
  480. // new one.
  481. foo_list = root.EnsureList("foo");
  482. ASSERT_EQ(1u, foo_list->size());
  483. EXPECT_EQ((*foo_list)[0], Value("a"));
  484. // Use EnsureList() to overwrite an existing non-list value.
  485. root.Set("bar", 3);
  486. Value::List* bar_list = root.EnsureList("bar");
  487. EXPECT_TRUE(bar_list->empty());
  488. bar_list->Append("b");
  489. // Test that the above call created a "bar" entry.
  490. bar_list = root.FindList("bar");
  491. ASSERT_NE(nullptr, bar_list);
  492. ASSERT_EQ(1u, bar_list->size());
  493. EXPECT_EQ((*bar_list)[0], Value("b"));
  494. }
  495. // TODO(dcheng): Add more tests directly exercising the updated dictionary and
  496. // list APIs. For now, most of the updated APIs are tested indirectly via the
  497. // legacy APIs that are largely backed by the updated APIs.
  498. TEST(ValuesTest, DictFindByDottedPath) {
  499. Value::Dict dict;
  500. EXPECT_EQ(nullptr, dict.FindByDottedPath("a.b.c"));
  501. Value::Dict& a_dict = dict.Set("a", Value::Dict())->GetDict();
  502. EXPECT_EQ(nullptr, dict.FindByDottedPath("a.b.c"));
  503. Value::Dict& b_dict = a_dict.Set("b", Value::Dict())->GetDict();
  504. EXPECT_EQ(nullptr, dict.FindByDottedPath("a.b.c"));
  505. b_dict.Set("c", true);
  506. const Value* value = dict.FindByDottedPath("a.b.c");
  507. ASSERT_NE(nullptr, value);
  508. EXPECT_TRUE(value->GetBool());
  509. }
  510. TEST(ValuesTest, DictSetByDottedPath) {
  511. Value::Dict dict;
  512. Value* c = dict.SetByDottedPath("a.b.c", Value());
  513. ASSERT_TRUE(c);
  514. Value::Dict* a = dict.FindDict("a");
  515. ASSERT_TRUE(a);
  516. EXPECT_EQ(1U, a->size());
  517. Value::Dict* b = a->FindDict("b");
  518. ASSERT_TRUE(b);
  519. EXPECT_EQ(1U, b->size());
  520. EXPECT_EQ(c, b->Find("c"));
  521. }
  522. TEST(ValuesTest, DictSetWithDottedKey) {
  523. Value::Dict dict;
  524. Value* abc = dict.Set("a.b.c", Value());
  525. ASSERT_TRUE(abc);
  526. EXPECT_FALSE(dict.FindByDottedPath("a"));
  527. EXPECT_FALSE(dict.FindByDottedPath("a.b"));
  528. EXPECT_FALSE(dict.FindByDottedPath("a.b.c"));
  529. EXPECT_EQ(abc, dict.Find("a.b.c"));
  530. }
  531. TEST(ValuesTest, ListFront) {
  532. Value::List list;
  533. const Value::List& const_list = list;
  534. list.Append(1);
  535. list.Append(2);
  536. list.Append(3);
  537. EXPECT_EQ(Value(1), list.front());
  538. EXPECT_EQ(Value(1), const_list.front());
  539. }
  540. TEST(ValuesTest, ListFrontWhenEmpty) {
  541. Value::List list;
  542. const Value::List& const_list = list;
  543. EXPECT_CHECK_DEATH(list.front());
  544. EXPECT_CHECK_DEATH(const_list.front());
  545. }
  546. TEST(ValuesTest, ListBack) {
  547. Value::List list;
  548. const Value::List& const_list = list;
  549. list.Append(1);
  550. list.Append(2);
  551. list.Append(3);
  552. EXPECT_EQ(Value(3), list.back());
  553. EXPECT_EQ(Value(3), const_list.back());
  554. }
  555. TEST(ValuesTest, ListBackWhenEmpty) {
  556. Value::List list;
  557. const Value::List& const_list = list;
  558. EXPECT_CHECK_DEATH(list.back());
  559. EXPECT_CHECK_DEATH(const_list.back());
  560. }
  561. TEST(ValuesTest, ListErase) {
  562. Value::List list;
  563. list.Append(1);
  564. list.Append(2);
  565. list.Append(3);
  566. auto next_it = list.erase(list.begin() + 1);
  567. ASSERT_EQ(2u, list.size());
  568. EXPECT_EQ(list[0], Value(1));
  569. EXPECT_EQ(list[1], Value(3));
  570. EXPECT_EQ(*next_it, Value(3));
  571. EXPECT_EQ(next_it + 1, list.end());
  572. }
  573. TEST(ValuesTest, ListEraseRange) {
  574. Value::List list;
  575. list.Append(1);
  576. list.Append(2);
  577. list.Append(3);
  578. list.Append(4);
  579. auto next_it = list.erase(list.begin() + 1, list.begin() + 3);
  580. ASSERT_EQ(2u, list.size());
  581. EXPECT_EQ(list[0], Value(1));
  582. EXPECT_EQ(list[1], Value(4));
  583. EXPECT_EQ(*next_it, Value(4));
  584. EXPECT_EQ(next_it + 1, list.end());
  585. next_it = list.erase(list.begin() + 1, list.begin() + 1);
  586. ASSERT_EQ(2u, list.size());
  587. EXPECT_EQ(list[0], Value(1));
  588. EXPECT_EQ(list[1], Value(4));
  589. EXPECT_EQ(*next_it, Value(4));
  590. EXPECT_EQ(next_it + 1, list.end());
  591. next_it = list.erase(list.begin() + 1, list.end());
  592. ASSERT_EQ(1u, list.size());
  593. EXPECT_EQ(list[0], Value(1));
  594. EXPECT_EQ(next_it, list.end());
  595. list.clear();
  596. next_it = list.erase(list.begin(), list.begin());
  597. ASSERT_EQ(0u, list.size());
  598. EXPECT_EQ(next_it, list.begin());
  599. EXPECT_EQ(next_it, list.end());
  600. }
  601. TEST(ValuesTest, EraseListIter) {
  602. ListValue value;
  603. value.Append(1);
  604. value.Append(2);
  605. value.Append(3);
  606. EXPECT_TRUE(value.EraseListIter(value.GetListDeprecated().begin() + 1));
  607. EXPECT_EQ(2u, value.GetListDeprecated().size());
  608. EXPECT_EQ(1, value.GetListDeprecated()[0].GetInt());
  609. EXPECT_EQ(3, value.GetListDeprecated()[1].GetInt());
  610. EXPECT_TRUE(value.EraseListIter(value.GetListDeprecated().begin()));
  611. EXPECT_EQ(1u, value.GetListDeprecated().size());
  612. EXPECT_EQ(3, value.GetListDeprecated()[0].GetInt());
  613. EXPECT_TRUE(value.EraseListIter(value.GetListDeprecated().begin()));
  614. EXPECT_TRUE(value.GetListDeprecated().empty());
  615. EXPECT_FALSE(value.EraseListIter(value.GetListDeprecated().begin()));
  616. }
  617. TEST(ValuesTest, EraseListValue) {
  618. ListValue value;
  619. value.Append(1);
  620. value.Append(2);
  621. value.Append(2);
  622. value.Append(3);
  623. EXPECT_EQ(2u, value.EraseListValue(Value(2)));
  624. EXPECT_EQ(2u, value.GetListDeprecated().size());
  625. EXPECT_EQ(1, value.GetListDeprecated()[0].GetInt());
  626. EXPECT_EQ(3, value.GetListDeprecated()[1].GetInt());
  627. EXPECT_EQ(1u, value.EraseListValue(Value(1)));
  628. EXPECT_EQ(1u, value.GetListDeprecated().size());
  629. EXPECT_EQ(3, value.GetListDeprecated()[0].GetInt());
  630. EXPECT_EQ(1u, value.EraseListValue(Value(3)));
  631. EXPECT_TRUE(value.GetListDeprecated().empty());
  632. EXPECT_EQ(0u, value.EraseListValue(Value(3)));
  633. }
  634. TEST(ValuesTest, EraseListValueIf) {
  635. ListValue value;
  636. value.Append(1);
  637. value.Append(2);
  638. value.Append(2);
  639. value.Append(3);
  640. EXPECT_EQ(3u, value.EraseListValueIf(
  641. [](const auto& val) { return val >= Value(2); }));
  642. EXPECT_EQ(1u, value.GetListDeprecated().size());
  643. EXPECT_EQ(1, value.GetListDeprecated()[0].GetInt());
  644. EXPECT_EQ(1u, value.EraseListValueIf([](const auto& val) { return true; }));
  645. EXPECT_TRUE(value.GetListDeprecated().empty());
  646. EXPECT_EQ(0u, value.EraseListValueIf([](const auto& val) { return true; }));
  647. }
  648. TEST(ValuesTest, ClearList) {
  649. ListValue value;
  650. value.Append(1);
  651. value.Append(2);
  652. value.Append(3);
  653. EXPECT_EQ(3u, value.GetListDeprecated().size());
  654. value.ClearList();
  655. EXPECT_TRUE(value.GetListDeprecated().empty());
  656. // ClearList() should be idempotent.
  657. value.ClearList();
  658. EXPECT_TRUE(value.GetListDeprecated().empty());
  659. }
  660. TEST(ValuesTest, FindKey) {
  661. Value::Dict dict;
  662. dict.Set("foo", "bar");
  663. Value value(std::move(dict));
  664. EXPECT_NE(nullptr, value.FindKey("foo"));
  665. EXPECT_EQ(nullptr, value.FindKey("baz"));
  666. // Single not found key.
  667. bool found = value.FindKey("notfound");
  668. EXPECT_FALSE(found);
  669. }
  670. TEST(ValuesTest, FindKeyChangeValue) {
  671. Value::Dict dict;
  672. dict.Set("foo", "bar");
  673. Value value(std::move(dict));
  674. Value* found = value.FindKey("foo");
  675. EXPECT_NE(nullptr, found);
  676. EXPECT_EQ("bar", found->GetString());
  677. *found = Value(123);
  678. EXPECT_EQ(123, value.FindKey("foo")->GetInt());
  679. }
  680. TEST(ValuesTest, FindKeyConst) {
  681. Value::Dict dict;
  682. dict.Set("foo", "bar");
  683. const Value value(std::move(dict));
  684. EXPECT_NE(nullptr, value.FindKey("foo"));
  685. EXPECT_EQ(nullptr, value.FindKey("baz"));
  686. }
  687. TEST(ValuesTest, FindKeyOfType) {
  688. Value::Dict dict;
  689. dict.Set("null", Value());
  690. dict.Set("bool", false);
  691. dict.Set("int", 0);
  692. dict.Set("double", 0.0);
  693. dict.Set("string", std::string());
  694. dict.Set("blob", Value(Value::BlobStorage()));
  695. dict.Set("list", Value::List());
  696. dict.Set("dict", Value::Dict());
  697. Value value(std::move(dict));
  698. EXPECT_NE(nullptr, value.FindKeyOfType("null", Value::Type::NONE));
  699. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::BOOLEAN));
  700. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::INTEGER));
  701. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::DOUBLE));
  702. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::STRING));
  703. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::BINARY));
  704. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::LIST));
  705. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::DICTIONARY));
  706. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::NONE));
  707. EXPECT_NE(nullptr, value.FindKeyOfType("bool", Value::Type::BOOLEAN));
  708. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::INTEGER));
  709. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::DOUBLE));
  710. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::STRING));
  711. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::BINARY));
  712. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::LIST));
  713. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::DICTIONARY));
  714. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::NONE));
  715. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::BOOLEAN));
  716. EXPECT_NE(nullptr, value.FindKeyOfType("int", Value::Type::INTEGER));
  717. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::DOUBLE));
  718. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::STRING));
  719. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::BINARY));
  720. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::LIST));
  721. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::DICTIONARY));
  722. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::NONE));
  723. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::BOOLEAN));
  724. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::INTEGER));
  725. EXPECT_NE(nullptr, value.FindKeyOfType("double", Value::Type::DOUBLE));
  726. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::STRING));
  727. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::BINARY));
  728. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::LIST));
  729. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::DICTIONARY));
  730. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::NONE));
  731. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::BOOLEAN));
  732. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::INTEGER));
  733. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::DOUBLE));
  734. EXPECT_NE(nullptr, value.FindKeyOfType("string", Value::Type::STRING));
  735. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::BINARY));
  736. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::LIST));
  737. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::DICTIONARY));
  738. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::NONE));
  739. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::BOOLEAN));
  740. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::INTEGER));
  741. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::DOUBLE));
  742. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::STRING));
  743. EXPECT_NE(nullptr, value.FindKeyOfType("blob", Value::Type::BINARY));
  744. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::LIST));
  745. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::DICTIONARY));
  746. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::NONE));
  747. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::BOOLEAN));
  748. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::INTEGER));
  749. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::DOUBLE));
  750. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::STRING));
  751. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::BINARY));
  752. EXPECT_NE(nullptr, value.FindKeyOfType("list", Value::Type::LIST));
  753. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::DICTIONARY));
  754. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::NONE));
  755. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::BOOLEAN));
  756. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::INTEGER));
  757. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::DOUBLE));
  758. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::STRING));
  759. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::BINARY));
  760. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::LIST));
  761. EXPECT_NE(nullptr, value.FindKeyOfType("dict", Value::Type::DICTIONARY));
  762. }
  763. TEST(ValuesTest, FindKeyOfTypeConst) {
  764. Value::Dict dict;
  765. dict.Set("null", Value());
  766. dict.Set("bool", false);
  767. dict.Set("int", 0);
  768. dict.Set("double", 0.0);
  769. dict.Set("string", std::string());
  770. dict.Set("blob", Value(Value::BlobStorage()));
  771. dict.Set("list", Value::List());
  772. dict.Set("dict", Value::Dict());
  773. const Value value(std::move(dict));
  774. EXPECT_NE(nullptr, value.FindKeyOfType("null", Value::Type::NONE));
  775. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::BOOLEAN));
  776. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::INTEGER));
  777. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::DOUBLE));
  778. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::STRING));
  779. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::BINARY));
  780. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::LIST));
  781. EXPECT_EQ(nullptr, value.FindKeyOfType("null", Value::Type::DICTIONARY));
  782. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::NONE));
  783. EXPECT_NE(nullptr, value.FindKeyOfType("bool", Value::Type::BOOLEAN));
  784. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::INTEGER));
  785. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::DOUBLE));
  786. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::STRING));
  787. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::BINARY));
  788. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::LIST));
  789. EXPECT_EQ(nullptr, value.FindKeyOfType("bool", Value::Type::DICTIONARY));
  790. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::NONE));
  791. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::BOOLEAN));
  792. EXPECT_NE(nullptr, value.FindKeyOfType("int", Value::Type::INTEGER));
  793. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::DOUBLE));
  794. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::STRING));
  795. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::BINARY));
  796. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::LIST));
  797. EXPECT_EQ(nullptr, value.FindKeyOfType("int", Value::Type::DICTIONARY));
  798. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::NONE));
  799. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::BOOLEAN));
  800. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::INTEGER));
  801. EXPECT_NE(nullptr, value.FindKeyOfType("double", Value::Type::DOUBLE));
  802. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::STRING));
  803. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::BINARY));
  804. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::LIST));
  805. EXPECT_EQ(nullptr, value.FindKeyOfType("double", Value::Type::DICTIONARY));
  806. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::NONE));
  807. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::BOOLEAN));
  808. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::INTEGER));
  809. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::DOUBLE));
  810. EXPECT_NE(nullptr, value.FindKeyOfType("string", Value::Type::STRING));
  811. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::BINARY));
  812. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::LIST));
  813. EXPECT_EQ(nullptr, value.FindKeyOfType("string", Value::Type::DICTIONARY));
  814. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::NONE));
  815. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::BOOLEAN));
  816. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::INTEGER));
  817. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::DOUBLE));
  818. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::STRING));
  819. EXPECT_NE(nullptr, value.FindKeyOfType("blob", Value::Type::BINARY));
  820. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::LIST));
  821. EXPECT_EQ(nullptr, value.FindKeyOfType("blob", Value::Type::DICTIONARY));
  822. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::NONE));
  823. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::BOOLEAN));
  824. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::INTEGER));
  825. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::DOUBLE));
  826. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::STRING));
  827. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::BINARY));
  828. EXPECT_NE(nullptr, value.FindKeyOfType("list", Value::Type::LIST));
  829. EXPECT_EQ(nullptr, value.FindKeyOfType("list", Value::Type::DICTIONARY));
  830. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::NONE));
  831. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::BOOLEAN));
  832. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::INTEGER));
  833. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::DOUBLE));
  834. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::STRING));
  835. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::BINARY));
  836. EXPECT_EQ(nullptr, value.FindKeyOfType("dict", Value::Type::LIST));
  837. EXPECT_NE(nullptr, value.FindKeyOfType("dict", Value::Type::DICTIONARY));
  838. }
  839. TEST(ValuesTest, FindBoolKey) {
  840. Value::Dict dict;
  841. dict.Set("null", Value());
  842. dict.Set("bool", false);
  843. dict.Set("int", 0);
  844. dict.Set("double", 0.0);
  845. dict.Set("string", std::string());
  846. dict.Set("blob", Value(Value::BlobStorage()));
  847. dict.Set("list", Value::List());
  848. dict.Set("dict", Value::Dict());
  849. const Value value(std::move(dict));
  850. EXPECT_EQ(absl::nullopt, value.FindBoolKey("null"));
  851. EXPECT_NE(absl::nullopt, value.FindBoolKey("bool"));
  852. EXPECT_EQ(absl::nullopt, value.FindBoolKey("int"));
  853. EXPECT_EQ(absl::nullopt, value.FindBoolKey("double"));
  854. EXPECT_EQ(absl::nullopt, value.FindBoolKey("string"));
  855. EXPECT_EQ(absl::nullopt, value.FindBoolKey("blob"));
  856. EXPECT_EQ(absl::nullopt, value.FindBoolKey("list"));
  857. EXPECT_EQ(absl::nullopt, value.FindBoolKey("dict"));
  858. }
  859. TEST(ValuesTest, FindIntKey) {
  860. Value::Dict dict;
  861. dict.Set("null", Value());
  862. dict.Set("bool", false);
  863. dict.Set("int", 0);
  864. dict.Set("double", 0.0);
  865. dict.Set("string", std::string());
  866. dict.Set("blob", Value(Value::BlobStorage()));
  867. dict.Set("list", Value::List());
  868. dict.Set("dict", Value::Dict());
  869. const Value value(std::move(dict));
  870. EXPECT_EQ(absl::nullopt, value.FindIntKey("null"));
  871. EXPECT_EQ(absl::nullopt, value.FindIntKey("bool"));
  872. EXPECT_NE(absl::nullopt, value.FindIntKey("int"));
  873. EXPECT_EQ(absl::nullopt, value.FindIntKey("double"));
  874. EXPECT_EQ(absl::nullopt, value.FindIntKey("string"));
  875. EXPECT_EQ(absl::nullopt, value.FindIntKey("blob"));
  876. EXPECT_EQ(absl::nullopt, value.FindIntKey("list"));
  877. EXPECT_EQ(absl::nullopt, value.FindIntKey("dict"));
  878. }
  879. TEST(ValuesTest, FindDoubleKey) {
  880. Value::Dict dict;
  881. dict.Set("null", Value());
  882. dict.Set("bool", false);
  883. dict.Set("int", 0);
  884. dict.Set("double", 0.0);
  885. dict.Set("string", std::string());
  886. dict.Set("blob", Value(Value::BlobStorage()));
  887. dict.Set("list", Value::List());
  888. dict.Set("dict", Value::Dict());
  889. const Value value(std::move(dict));
  890. EXPECT_EQ(absl::nullopt, value.FindDoubleKey("null"));
  891. EXPECT_EQ(absl::nullopt, value.FindDoubleKey("bool"));
  892. EXPECT_NE(absl::nullopt, value.FindDoubleKey("int"));
  893. EXPECT_NE(absl::nullopt, value.FindDoubleKey("double"));
  894. EXPECT_EQ(absl::nullopt, value.FindDoubleKey("string"));
  895. EXPECT_EQ(absl::nullopt, value.FindDoubleKey("blob"));
  896. EXPECT_EQ(absl::nullopt, value.FindDoubleKey("list"));
  897. EXPECT_EQ(absl::nullopt, value.FindDoubleKey("dict"));
  898. }
  899. TEST(ValuesTest, FindStringKey) {
  900. Value::Dict dict;
  901. dict.Set("null", Value());
  902. dict.Set("bool", false);
  903. dict.Set("int", 0);
  904. dict.Set("double", 0.0);
  905. dict.Set("string", std::string());
  906. dict.Set("blob", Value(Value::BlobStorage()));
  907. dict.Set("list", Value::List());
  908. dict.Set("dict", Value::Dict());
  909. const Value value(std::move(dict));
  910. EXPECT_EQ(nullptr, value.FindStringKey("null"));
  911. EXPECT_EQ(nullptr, value.FindStringKey("bool"));
  912. EXPECT_EQ(nullptr, value.FindStringKey("int"));
  913. EXPECT_EQ(nullptr, value.FindStringKey("double"));
  914. EXPECT_NE(nullptr, value.FindStringKey("string"));
  915. EXPECT_EQ(nullptr, value.FindStringKey("blob"));
  916. EXPECT_EQ(nullptr, value.FindStringKey("list"));
  917. EXPECT_EQ(nullptr, value.FindStringKey("dict"));
  918. }
  919. TEST(ValuesTest, MutableFindStringKey) {
  920. Value::Dict dict;
  921. dict.Set("string", "foo");
  922. Value value(std::move(dict));
  923. *(value.FindStringKey("string")) = "bar";
  924. Value::Dict expected_dict;
  925. expected_dict.Set("string", "bar");
  926. Value expected_value(std::move(expected_dict));
  927. EXPECT_EQ(expected_value, value);
  928. }
  929. TEST(ValuesTest, FindDictKey) {
  930. Value::Dict dict;
  931. dict.Set("null", Value());
  932. dict.Set("bool", false);
  933. dict.Set("int", 0);
  934. dict.Set("double", 0.0);
  935. dict.Set("string", std::string());
  936. dict.Set("blob", Value(Value::BlobStorage()));
  937. dict.Set("list", Value::List());
  938. dict.Set("dict", Value::Dict());
  939. const Value value(std::move(dict));
  940. EXPECT_EQ(nullptr, value.FindDictKey("null"));
  941. EXPECT_EQ(nullptr, value.FindDictKey("bool"));
  942. EXPECT_EQ(nullptr, value.FindDictKey("int"));
  943. EXPECT_EQ(nullptr, value.FindDictKey("double"));
  944. EXPECT_EQ(nullptr, value.FindDictKey("string"));
  945. EXPECT_EQ(nullptr, value.FindDictKey("blob"));
  946. EXPECT_EQ(nullptr, value.FindDictKey("list"));
  947. EXPECT_NE(nullptr, value.FindDictKey("dict"));
  948. }
  949. TEST(ValuesTest, FindListKey) {
  950. Value::Dict dict;
  951. dict.Set("null", Value());
  952. dict.Set("bool", false);
  953. dict.Set("int", 0);
  954. dict.Set("double", 0.0);
  955. dict.Set("string", std::string());
  956. dict.Set("blob", Value(Value::BlobStorage()));
  957. dict.Set("list", Value::List());
  958. dict.Set("dict", Value::Dict());
  959. const Value value(std::move(dict));
  960. EXPECT_EQ(nullptr, value.FindListKey("null"));
  961. EXPECT_EQ(nullptr, value.FindListKey("bool"));
  962. EXPECT_EQ(nullptr, value.FindListKey("int"));
  963. EXPECT_EQ(nullptr, value.FindListKey("double"));
  964. EXPECT_EQ(nullptr, value.FindListKey("string"));
  965. EXPECT_EQ(nullptr, value.FindListKey("blob"));
  966. EXPECT_NE(nullptr, value.FindListKey("list"));
  967. EXPECT_EQ(nullptr, value.FindListKey("dict"));
  968. }
  969. TEST(ValuesTest, FindBlobKey) {
  970. Value::Dict dict;
  971. dict.Set("null", Value());
  972. dict.Set("bool", false);
  973. dict.Set("int", 0);
  974. dict.Set("double", 0.0);
  975. dict.Set("string", std::string());
  976. dict.Set("blob", Value(Value::BlobStorage()));
  977. dict.Set("list", Value::List());
  978. dict.Set("dict", Value::Dict());
  979. const Value value(std::move(dict));
  980. EXPECT_EQ(nullptr, value.FindBlobKey("null"));
  981. EXPECT_EQ(nullptr, value.FindBlobKey("bool"));
  982. EXPECT_EQ(nullptr, value.FindBlobKey("int"));
  983. EXPECT_EQ(nullptr, value.FindBlobKey("double"));
  984. EXPECT_EQ(nullptr, value.FindBlobKey("string"));
  985. EXPECT_NE(nullptr, value.FindBlobKey("blob"));
  986. EXPECT_EQ(nullptr, value.FindBlobKey("list"));
  987. EXPECT_EQ(nullptr, value.FindBlobKey("dict"));
  988. }
  989. TEST(ValuesTest, SetKey) {
  990. Value::Dict dict;
  991. dict.Set("null", Value());
  992. dict.Set("bool", false);
  993. dict.Set("int", 0);
  994. dict.Set("double", 0.0);
  995. dict.Set("string", std::string());
  996. dict.Set("blob", Value(Value::BlobStorage()));
  997. dict.Set("list", Value::List());
  998. dict.Set("dict", Value::Dict());
  999. Value value(Value::Type::DICTIONARY);
  1000. value.SetKey(StringPiece("null"), Value(Value::Type::NONE));
  1001. value.SetKey(StringPiece("bool"), Value(Value::Type::BOOLEAN));
  1002. value.SetKey(std::string("int"), Value(Value::Type::INTEGER));
  1003. value.SetKey(std::string("double"), Value(Value::Type::DOUBLE));
  1004. value.SetKey(std::string("string"), Value(Value::Type::STRING));
  1005. value.SetKey("blob", Value(Value::Type::BINARY));
  1006. value.SetKey("list", Value(Value::Type::LIST));
  1007. value.SetKey("dict", Value(Value::Type::DICTIONARY));
  1008. EXPECT_EQ(Value(std::move(dict)), value);
  1009. }
  1010. TEST(ValuesTest, SetBoolKey) {
  1011. absl::optional<bool> value;
  1012. DictionaryValue dict;
  1013. dict.SetBoolKey("true_key", true);
  1014. dict.SetBoolKey("false_key", false);
  1015. value = dict.FindBoolKey("true_key");
  1016. ASSERT_TRUE(value);
  1017. ASSERT_TRUE(*value);
  1018. value = dict.FindBoolKey("false_key");
  1019. ASSERT_TRUE(value);
  1020. ASSERT_FALSE(*value);
  1021. value = dict.FindBoolKey("missing_key");
  1022. ASSERT_FALSE(value);
  1023. }
  1024. TEST(ValuesTest, SetIntKey) {
  1025. absl::optional<int> value;
  1026. DictionaryValue dict;
  1027. dict.SetIntKey("one_key", 1);
  1028. dict.SetIntKey("minus_one_key", -1);
  1029. value = dict.FindIntKey("one_key");
  1030. ASSERT_TRUE(value);
  1031. ASSERT_EQ(1, *value);
  1032. value = dict.FindIntKey("minus_one_key");
  1033. ASSERT_TRUE(value);
  1034. ASSERT_EQ(-1, *value);
  1035. value = dict.FindIntKey("missing_key");
  1036. ASSERT_FALSE(value);
  1037. }
  1038. TEST(ValuesTest, SetDoubleKey) {
  1039. DictionaryValue dict;
  1040. dict.SetDoubleKey("one_key", 1.0);
  1041. dict.SetDoubleKey("minus_one_key", -1.0);
  1042. dict.SetDoubleKey("pi_key", 3.1415);
  1043. // NOTE: Use FindKey() instead of FindDoubleKey() because the latter will
  1044. // auto-convert integers to doubles as well.
  1045. const Value* value;
  1046. value = dict.FindKey("one_key");
  1047. ASSERT_TRUE(value);
  1048. EXPECT_TRUE(value->is_double());
  1049. EXPECT_EQ(1.0, value->GetDouble());
  1050. value = dict.FindKey("minus_one_key");
  1051. ASSERT_TRUE(value);
  1052. EXPECT_TRUE(value->is_double());
  1053. EXPECT_EQ(-1.0, value->GetDouble());
  1054. value = dict.FindKey("pi_key");
  1055. ASSERT_TRUE(value);
  1056. EXPECT_TRUE(value->is_double());
  1057. EXPECT_EQ(3.1415, value->GetDouble());
  1058. }
  1059. TEST(ValuesTest, SetStringKey) {
  1060. DictionaryValue dict;
  1061. dict.SetStringKey("one_key", "one");
  1062. dict.SetStringKey("hello_key", "hello world");
  1063. std::string movable_value("movable_value");
  1064. dict.SetStringKey("movable_key", std::move(movable_value));
  1065. ASSERT_TRUE(movable_value.empty());
  1066. const std::string* value;
  1067. value = dict.FindStringKey("one_key");
  1068. ASSERT_TRUE(value);
  1069. ASSERT_EQ("one", *value);
  1070. value = dict.FindStringKey("hello_key");
  1071. ASSERT_TRUE(value);
  1072. ASSERT_EQ("hello world", *value);
  1073. value = dict.FindStringKey("movable_key");
  1074. ASSERT_TRUE(value);
  1075. ASSERT_EQ("movable_value", *value);
  1076. value = dict.FindStringKey("missing_key");
  1077. ASSERT_FALSE(value);
  1078. }
  1079. TEST(ValuesTest, FindPath) {
  1080. // Construct a dictionary path {root}.foo.bar = 123
  1081. Value foo(Value::Type::DICTIONARY);
  1082. foo.SetKey("bar", Value(123));
  1083. Value root(Value::Type::DICTIONARY);
  1084. root.SetKey("foo", std::move(foo));
  1085. // Double key, second not found.
  1086. Value* found = root.FindPath("foo.notfound");
  1087. EXPECT_FALSE(found);
  1088. // Double key, found.
  1089. found = root.FindPath("foo.bar");
  1090. EXPECT_TRUE(found);
  1091. EXPECT_TRUE(found->is_int());
  1092. EXPECT_EQ(123, found->GetInt());
  1093. }
  1094. TEST(ValuesTest, SetPath) {
  1095. Value root(Value::Type::DICTIONARY);
  1096. Value* inserted = root.SetPath("one.two", Value(123));
  1097. Value* found = root.FindPathOfType("one.two", Value::Type::INTEGER);
  1098. ASSERT_TRUE(found);
  1099. EXPECT_EQ(inserted, found);
  1100. EXPECT_EQ(123, found->GetInt());
  1101. inserted = root.SetPath("foo.bar", Value(123));
  1102. found = root.FindPathOfType("foo.bar", Value::Type::INTEGER);
  1103. ASSERT_TRUE(found);
  1104. EXPECT_EQ(inserted, found);
  1105. EXPECT_EQ(123, found->GetInt());
  1106. // Overwrite with a different value.
  1107. root.SetPath("foo.bar", Value("hello"));
  1108. found = root.FindPathOfType("foo.bar", Value::Type::STRING);
  1109. ASSERT_TRUE(found);
  1110. EXPECT_EQ("hello", found->GetString());
  1111. // Can't change existing non-dictionary keys to dictionaries.
  1112. found = root.SetPath("foo.bar.baz", Value(123));
  1113. EXPECT_FALSE(found);
  1114. }
  1115. TEST(ValuesTest, SetBoolPath) {
  1116. DictionaryValue root;
  1117. Value* inserted = root.SetBoolPath("foo.bar", true);
  1118. Value* found = root.FindPath("foo.bar");
  1119. ASSERT_TRUE(found);
  1120. EXPECT_EQ(inserted, found);
  1121. ASSERT_TRUE(found->is_bool());
  1122. EXPECT_TRUE(found->GetBool());
  1123. // Overwrite with a different value.
  1124. root.SetBoolPath("foo.bar", false);
  1125. found = root.FindPath("foo.bar");
  1126. ASSERT_TRUE(found);
  1127. ASSERT_TRUE(found->is_bool());
  1128. EXPECT_FALSE(found->GetBool());
  1129. // Can't change existing non-dictionary keys.
  1130. ASSERT_FALSE(root.SetBoolPath("foo.bar.zoo", true));
  1131. }
  1132. TEST(ValuesTest, SetIntPath) {
  1133. DictionaryValue root;
  1134. Value* inserted = root.SetIntPath("foo.bar", 123);
  1135. Value* found = root.FindPath("foo.bar");
  1136. ASSERT_TRUE(found);
  1137. EXPECT_EQ(inserted, found);
  1138. ASSERT_TRUE(found->is_int());
  1139. EXPECT_EQ(123, found->GetInt());
  1140. // Overwrite with a different value.
  1141. root.SetIntPath("foo.bar", 234);
  1142. found = root.FindPath("foo.bar");
  1143. ASSERT_TRUE(found);
  1144. ASSERT_TRUE(found->is_int());
  1145. EXPECT_EQ(234, found->GetInt());
  1146. // Can't change existing non-dictionary keys.
  1147. ASSERT_FALSE(root.SetIntPath("foo.bar.zoo", 567));
  1148. }
  1149. TEST(ValuesTest, SetDoublePath) {
  1150. DictionaryValue root;
  1151. Value* inserted = root.SetDoublePath("foo.bar", 1.23);
  1152. Value* found = root.FindPath("foo.bar");
  1153. ASSERT_TRUE(found);
  1154. EXPECT_EQ(inserted, found);
  1155. ASSERT_TRUE(found->is_double());
  1156. EXPECT_EQ(1.23, found->GetDouble());
  1157. // Overwrite with a different value.
  1158. root.SetDoublePath("foo.bar", 2.34);
  1159. found = root.FindPath("foo.bar");
  1160. ASSERT_TRUE(found);
  1161. ASSERT_TRUE(found->is_double());
  1162. EXPECT_EQ(2.34, found->GetDouble());
  1163. // Can't change existing non-dictionary keys.
  1164. ASSERT_FALSE(root.SetDoublePath("foo.bar.zoo", 5.67));
  1165. }
  1166. TEST(ValuesTest, SetStringPath) {
  1167. DictionaryValue root;
  1168. Value* inserted = root.SetStringPath("foo.bar", "hello world");
  1169. Value* found = root.FindPath("foo.bar");
  1170. ASSERT_TRUE(found);
  1171. EXPECT_EQ(inserted, found);
  1172. ASSERT_TRUE(found->is_string());
  1173. EXPECT_EQ("hello world", found->GetString());
  1174. // Overwrite with a different value.
  1175. root.SetStringPath("foo.bar", "bonjour monde");
  1176. found = root.FindPath("foo.bar");
  1177. ASSERT_TRUE(found);
  1178. ASSERT_TRUE(found->is_string());
  1179. EXPECT_EQ("bonjour monde", found->GetString());
  1180. ASSERT_TRUE(root.SetStringPath("foo.bar", StringPiece("rah rah")));
  1181. ASSERT_TRUE(root.SetStringPath("foo.bar", std::string("temp string")));
  1182. ASSERT_TRUE(root.SetStringPath("foo.bar", u"temp string"));
  1183. // Can't change existing non-dictionary keys.
  1184. ASSERT_FALSE(root.SetStringPath("foo.bar.zoo", "ola mundo"));
  1185. }
  1186. TEST(ValuesTest, RemoveKey) {
  1187. Value root(Value::Type::DICTIONARY);
  1188. root.SetKey("one", Value(123));
  1189. // Removal of missing key should fail.
  1190. EXPECT_FALSE(root.RemoveKey("two"));
  1191. // Removal of existing key should succeed.
  1192. EXPECT_TRUE(root.RemoveKey("one"));
  1193. // Second removal of previously existing key should fail.
  1194. EXPECT_FALSE(root.RemoveKey("one"));
  1195. }
  1196. TEST(ValuesTest, ExtractKey) {
  1197. Value root(Value::Type::DICTIONARY);
  1198. root.SetKey("one", Value(123));
  1199. // Extraction of missing key should fail.
  1200. EXPECT_EQ(absl::nullopt, root.ExtractKey("two"));
  1201. // Extraction of existing key should succeed.
  1202. EXPECT_EQ(Value(123), root.ExtractKey("one"));
  1203. // Second extraction of previously existing key should fail.
  1204. EXPECT_EQ(absl::nullopt, root.ExtractKey("one"));
  1205. }
  1206. TEST(ValuesTest, RemovePath) {
  1207. Value root(Value::Type::DICTIONARY);
  1208. root.SetPath("one.two.three", Value(123));
  1209. // Removal of missing key should fail.
  1210. EXPECT_FALSE(root.RemovePath("one.two.four"));
  1211. // Removal of existing key should succeed.
  1212. EXPECT_TRUE(root.RemovePath("one.two.three"));
  1213. // Second removal of previously existing key should fail.
  1214. EXPECT_FALSE(root.RemovePath("one.two.three"));
  1215. // Intermediate empty dictionaries should be cleared.
  1216. EXPECT_EQ(nullptr, root.FindKey("one"));
  1217. root.SetPath("one.two.three", Value(123));
  1218. root.SetPath("one.two.four", Value(124));
  1219. EXPECT_TRUE(root.RemovePath("one.two.three"));
  1220. // Intermediate non-empty dictionaries should be kept.
  1221. EXPECT_NE(nullptr, root.FindKey("one"));
  1222. EXPECT_NE(nullptr, root.FindPath("one.two"));
  1223. EXPECT_NE(nullptr, root.FindPath("one.two.four"));
  1224. }
  1225. TEST(ValuesTest, ExtractPath) {
  1226. Value root(Value::Type::DICTIONARY);
  1227. root.SetPath("one.two.three", Value(123));
  1228. // Extraction of missing key should fail.
  1229. EXPECT_EQ(absl::nullopt, root.ExtractPath("one.two.four"));
  1230. // Extraction of existing key should succeed.
  1231. EXPECT_EQ(Value(123), root.ExtractPath("one.two.three"));
  1232. // Second extraction of previously existing key should fail.
  1233. EXPECT_EQ(absl::nullopt, root.ExtractPath("one.two.three"));
  1234. // Intermediate empty dictionaries should be cleared.
  1235. EXPECT_EQ(nullptr, root.FindKey("one"));
  1236. root.SetPath("one.two.three", Value(123));
  1237. root.SetPath("one.two.four", Value(124));
  1238. EXPECT_EQ(Value(123), root.ExtractPath("one.two.three"));
  1239. // Intermediate non-empty dictionaries should be kept.
  1240. EXPECT_NE(nullptr, root.FindKey("one"));
  1241. EXPECT_NE(nullptr, root.FindPath("one.two"));
  1242. EXPECT_NE(nullptr, root.FindPath("one.two.four"));
  1243. }
  1244. TEST(ValuesTest, Basic) {
  1245. // Test basic dictionary getting/setting
  1246. DictionaryValue settings;
  1247. ASSERT_FALSE(settings.FindPath("global.homepage"));
  1248. ASSERT_FALSE(settings.FindKey("global"));
  1249. settings.SetKey("global", Value(true));
  1250. ASSERT_TRUE(settings.FindKey("global"));
  1251. settings.RemoveKey("global");
  1252. settings.SetPath("global.homepage", Value("http://scurvy.com"));
  1253. ASSERT_TRUE(settings.FindKey("global"));
  1254. const std::string* homepage = settings.FindStringPath("global.homepage");
  1255. ASSERT_TRUE(homepage);
  1256. ASSERT_EQ(std::string("http://scurvy.com"), *homepage);
  1257. // Test storing a dictionary in a list.
  1258. ASSERT_FALSE(settings.FindPath("global.toolbar.bookmarks"));
  1259. ListValue new_toolbar_bookmarks;
  1260. settings.SetPath("global.toolbar.bookmarks",
  1261. std::move(new_toolbar_bookmarks));
  1262. Value* toolbar_bookmarks = settings.FindListPath("global.toolbar.bookmarks");
  1263. ASSERT_TRUE(toolbar_bookmarks);
  1264. DictionaryValue new_bookmark;
  1265. new_bookmark.SetKey("name", Value("Froogle"));
  1266. new_bookmark.SetKey("url", Value("http://froogle.com"));
  1267. toolbar_bookmarks->Append(std::move(new_bookmark));
  1268. Value* bookmark_list = settings.FindPath("global.toolbar.bookmarks");
  1269. ASSERT_TRUE(bookmark_list);
  1270. ASSERT_EQ(1U, bookmark_list->GetListDeprecated().size());
  1271. Value* bookmark = &bookmark_list->GetListDeprecated()[0];
  1272. ASSERT_TRUE(bookmark);
  1273. ASSERT_TRUE(bookmark->is_dict());
  1274. const std::string* bookmark_name = bookmark->FindStringKey("name");
  1275. ASSERT_TRUE(bookmark_name);
  1276. ASSERT_EQ(std::string("Froogle"), *bookmark_name);
  1277. const std::string* bookmark_url = bookmark->FindStringKey("url");
  1278. ASSERT_TRUE(bookmark_url);
  1279. ASSERT_EQ(std::string("http://froogle.com"), *bookmark_url);
  1280. }
  1281. TEST(ValuesTest, List) {
  1282. Value mixed_list(Value::Type::LIST);
  1283. mixed_list.Append(true);
  1284. mixed_list.Append(42);
  1285. mixed_list.Append(88.8);
  1286. mixed_list.Append("foo");
  1287. Value::ConstListView list_view = mixed_list.GetListDeprecated();
  1288. ASSERT_EQ(4u, list_view.size());
  1289. ASSERT_FALSE(list_view[0].is_int());
  1290. ASSERT_FALSE(list_view[1].is_bool());
  1291. ASSERT_FALSE(list_view[2].is_string());
  1292. ASSERT_FALSE(list_view[2].is_int());
  1293. ASSERT_FALSE(list_view[2].is_bool());
  1294. ASSERT_TRUE(list_view[0].is_bool());
  1295. ASSERT_TRUE(list_view[1].is_int());
  1296. ASSERT_EQ(42, list_view[1].GetInt());
  1297. // Implicit conversion from Integer to Double should be possible.
  1298. ASSERT_EQ(42, list_view[1].GetDouble());
  1299. ASSERT_EQ(88.8, list_view[2].GetDouble());
  1300. ASSERT_EQ("foo", list_view[3].GetString());
  1301. // Try searching in the mixed list.
  1302. ASSERT_TRUE(Contains(list_view, base::Value(42)));
  1303. ASSERT_FALSE(Contains(list_view, base::Value(false)));
  1304. }
  1305. TEST(ValuesTest, BinaryValue) {
  1306. // Default constructor creates a BinaryValue with a buffer of size 0.
  1307. Value binary(Value::Type::BINARY);
  1308. ASSERT_TRUE(binary.GetBlob().empty());
  1309. // Test the common case of a non-empty buffer
  1310. Value::BlobStorage buffer(15);
  1311. uint8_t* original_buffer = buffer.data();
  1312. binary = Value(std::move(buffer));
  1313. ASSERT_TRUE(binary.GetBlob().data());
  1314. ASSERT_EQ(original_buffer, binary.GetBlob().data());
  1315. ASSERT_EQ(15U, binary.GetBlob().size());
  1316. char stack_buffer[42];
  1317. memset(stack_buffer, '!', 42);
  1318. binary = Value(Value::BlobStorage(stack_buffer, stack_buffer + 42));
  1319. ASSERT_TRUE(binary.GetBlob().data());
  1320. ASSERT_NE(stack_buffer,
  1321. reinterpret_cast<const char*>(binary.GetBlob().data()));
  1322. ASSERT_EQ(42U, binary.GetBlob().size());
  1323. ASSERT_EQ(0, memcmp(stack_buffer, binary.GetBlob().data(),
  1324. binary.GetBlob().size()));
  1325. }
  1326. TEST(ValuesTest, StringValue) {
  1327. // Test overloaded StringValue constructor.
  1328. std::unique_ptr<Value> narrow_value(new Value("narrow"));
  1329. ASSERT_TRUE(narrow_value.get());
  1330. ASSERT_TRUE(narrow_value->is_string());
  1331. std::unique_ptr<Value> utf16_value(new Value(u"utf16"));
  1332. ASSERT_TRUE(utf16_value.get());
  1333. ASSERT_TRUE(utf16_value->is_string());
  1334. ASSERT_TRUE(narrow_value->is_string());
  1335. ASSERT_EQ(std::string("narrow"), narrow_value->GetString());
  1336. ASSERT_TRUE(utf16_value->is_string());
  1337. ASSERT_EQ(std::string("utf16"), utf16_value->GetString());
  1338. }
  1339. TEST(ValuesTest, ListDeletion) {
  1340. ListValue list;
  1341. list.Append(Value());
  1342. EXPECT_FALSE(list.GetList().empty());
  1343. list.ClearList();
  1344. EXPECT_TRUE(list.GetListDeprecated().empty());
  1345. }
  1346. TEST(ValuesTest, DictionaryDeletion) {
  1347. std::string key = "test";
  1348. DictionaryValue dict;
  1349. dict.Set(key, std::make_unique<Value>());
  1350. EXPECT_FALSE(dict.DictEmpty());
  1351. EXPECT_FALSE(dict.DictEmpty());
  1352. EXPECT_EQ(1U, dict.DictSize());
  1353. dict.DictClear();
  1354. EXPECT_TRUE(dict.DictEmpty());
  1355. EXPECT_TRUE(dict.DictEmpty());
  1356. EXPECT_EQ(0U, dict.DictSize());
  1357. }
  1358. TEST(ValuesTest, DictionarySetReturnsPointer) {
  1359. {
  1360. DictionaryValue dict;
  1361. Value* blank_ptr = dict.Set("foo.bar", std::make_unique<base::Value>());
  1362. EXPECT_EQ(Value::Type::NONE, blank_ptr->type());
  1363. }
  1364. {
  1365. DictionaryValue dict;
  1366. Value* blank_ptr = dict.SetKey("foo.bar", base::Value());
  1367. EXPECT_EQ(Value::Type::NONE, blank_ptr->type());
  1368. }
  1369. {
  1370. DictionaryValue dict;
  1371. Value* int_ptr = dict.SetInteger("foo.bar", 42);
  1372. EXPECT_EQ(Value::Type::INTEGER, int_ptr->type());
  1373. EXPECT_EQ(42, int_ptr->GetInt());
  1374. }
  1375. {
  1376. DictionaryValue dict;
  1377. Value* string_ptr = dict.SetString("foo.bar", "foo");
  1378. EXPECT_EQ(Value::Type::STRING, string_ptr->type());
  1379. EXPECT_EQ("foo", string_ptr->GetString());
  1380. }
  1381. {
  1382. DictionaryValue dict;
  1383. Value* string16_ptr = dict.SetString("foo.bar", u"baz");
  1384. EXPECT_EQ(Value::Type::STRING, string16_ptr->type());
  1385. EXPECT_EQ("baz", string16_ptr->GetString());
  1386. }
  1387. {
  1388. DictionaryValue dict;
  1389. Value* dict_ptr =
  1390. dict.SetPath("foo.bar", base::Value(base::Value::Type::DICTIONARY));
  1391. EXPECT_EQ(Value::Type::DICTIONARY, dict_ptr->type());
  1392. }
  1393. {
  1394. DictionaryValue dict;
  1395. ListValue* list_ptr =
  1396. dict.SetList("foo.bar", std::make_unique<base::ListValue>());
  1397. EXPECT_EQ(Value::Type::LIST, list_ptr->type());
  1398. }
  1399. }
  1400. // Tests the deprecated version of SetWithoutPathExpansion.
  1401. // TODO(estade): remove.
  1402. TEST(ValuesTest, DictionaryWithoutPathExpansionDeprecated) {
  1403. DictionaryValue dict;
  1404. dict.Set("this.is.expanded", std::make_unique<Value>());
  1405. dict.SetWithoutPathExpansion("this.isnt.expanded", std::make_unique<Value>());
  1406. EXPECT_FALSE(dict.FindKey("this.is.expanded"));
  1407. EXPECT_TRUE(dict.FindKey("this"));
  1408. Value* value1;
  1409. EXPECT_TRUE(dict.Get("this", &value1));
  1410. ASSERT_TRUE(dict.GetDict().FindDict("this"));
  1411. DictionaryValue* value2 =
  1412. static_cast<DictionaryValue*>(dict.GetDict().Find("this"));
  1413. ASSERT_TRUE(value2);
  1414. EXPECT_EQ(value1, value2);
  1415. EXPECT_EQ(1U, value2->DictSize());
  1416. EXPECT_TRUE(dict.FindKey("this.isnt.expanded"));
  1417. Value* value3;
  1418. EXPECT_FALSE(dict.Get("this.isnt.expanded", &value3));
  1419. Value* value4 = dict.FindKey("this.isnt.expanded");
  1420. ASSERT_TRUE(value4);
  1421. EXPECT_EQ(Value::Type::NONE, value4->type());
  1422. }
  1423. TEST(ValuesTest, DeepCopy) {
  1424. DictionaryValue original_dict;
  1425. Value* null_weak = original_dict.SetKey("null", Value());
  1426. Value* bool_weak = original_dict.SetKey("bool", Value(true));
  1427. Value* int_weak = original_dict.SetKey("int", Value(42));
  1428. Value* double_weak = original_dict.SetKey("double", Value(3.14));
  1429. Value* string_weak = original_dict.SetKey("string", Value("hello"));
  1430. Value* string16_weak = original_dict.SetKey("string16", Value(u"hello16"));
  1431. Value* binary_weak =
  1432. original_dict.SetKey("binary", Value(Value::BlobStorage(42, '!')));
  1433. Value::List list;
  1434. list.Append(0);
  1435. list.Append(1);
  1436. Value* list_weak = original_dict.SetKey("list", Value(std::move(list)));
  1437. Value* dict_weak = original_dict.SetKey(
  1438. "dictionary", base::Value(base::Value::Type::DICTIONARY));
  1439. dict_weak->SetStringKey("key", "value");
  1440. auto copy_dict = original_dict.CreateDeepCopy();
  1441. ASSERT_TRUE(copy_dict.get());
  1442. ASSERT_NE(copy_dict.get(), &original_dict);
  1443. Value* copy_null = nullptr;
  1444. ASSERT_TRUE(copy_dict->Get("null", &copy_null));
  1445. ASSERT_TRUE(copy_null);
  1446. ASSERT_NE(copy_null, null_weak);
  1447. ASSERT_TRUE(copy_null->is_none());
  1448. Value* copy_bool = nullptr;
  1449. ASSERT_TRUE(copy_dict->Get("bool", &copy_bool));
  1450. ASSERT_TRUE(copy_bool);
  1451. ASSERT_NE(copy_bool, bool_weak);
  1452. ASSERT_TRUE(copy_bool->is_bool());
  1453. ASSERT_TRUE(copy_bool->GetBool());
  1454. Value* copy_int = nullptr;
  1455. ASSERT_TRUE(copy_dict->Get("int", &copy_int));
  1456. ASSERT_TRUE(copy_int);
  1457. ASSERT_NE(copy_int, int_weak);
  1458. ASSERT_TRUE(copy_int->is_int());
  1459. ASSERT_EQ(42, copy_int->GetInt());
  1460. Value* copy_double = nullptr;
  1461. ASSERT_TRUE(copy_dict->Get("double", &copy_double));
  1462. ASSERT_TRUE(copy_double);
  1463. ASSERT_NE(copy_double, double_weak);
  1464. ASSERT_TRUE(copy_double->is_double());
  1465. ASSERT_EQ(3.14, copy_double->GetDouble());
  1466. Value* copy_string = nullptr;
  1467. ASSERT_TRUE(copy_dict->Get("string", &copy_string));
  1468. ASSERT_TRUE(copy_string);
  1469. ASSERT_NE(copy_string, string_weak);
  1470. ASSERT_TRUE(copy_string->is_string());
  1471. ASSERT_EQ(std::string("hello"), copy_string->GetString());
  1472. Value* copy_string16 = nullptr;
  1473. ASSERT_TRUE(copy_dict->Get("string16", &copy_string16));
  1474. ASSERT_TRUE(copy_string16);
  1475. ASSERT_NE(copy_string16, string16_weak);
  1476. ASSERT_TRUE(copy_string16->is_string());
  1477. ASSERT_EQ(std::string("hello16"), copy_string16->GetString());
  1478. Value* copy_binary = nullptr;
  1479. ASSERT_TRUE(copy_dict->Get("binary", &copy_binary));
  1480. ASSERT_TRUE(copy_binary);
  1481. ASSERT_NE(copy_binary, binary_weak);
  1482. ASSERT_TRUE(copy_binary->is_blob());
  1483. ASSERT_NE(binary_weak->GetBlob().data(), copy_binary->GetBlob().data());
  1484. ASSERT_EQ(binary_weak->GetBlob(), copy_binary->GetBlob());
  1485. Value* copy_value = nullptr;
  1486. ASSERT_TRUE(copy_dict->Get("list", &copy_value));
  1487. ASSERT_TRUE(copy_value);
  1488. ASSERT_NE(copy_value, list_weak);
  1489. ASSERT_TRUE(copy_value->is_list());
  1490. ASSERT_EQ(2U, copy_value->GetList().size());
  1491. copy_value = nullptr;
  1492. ASSERT_TRUE(copy_dict->Get("dictionary", &copy_value));
  1493. ASSERT_TRUE(copy_value);
  1494. ASSERT_NE(copy_value, dict_weak);
  1495. ASSERT_TRUE(copy_value->is_dict());
  1496. DictionaryValue* copy_nested_dictionary = nullptr;
  1497. ASSERT_TRUE(copy_value->GetAsDictionary(&copy_nested_dictionary));
  1498. ASSERT_TRUE(copy_nested_dictionary);
  1499. EXPECT_TRUE(copy_nested_dictionary->FindKey("key"));
  1500. }
  1501. TEST(ValuesTest, SpecializedEquals) {
  1502. std::vector<Value> values;
  1503. values.emplace_back(false);
  1504. values.emplace_back(true);
  1505. values.emplace_back(0);
  1506. values.emplace_back(1);
  1507. values.emplace_back(1.0);
  1508. values.emplace_back(2.0);
  1509. values.emplace_back("hello");
  1510. values.emplace_back("world");
  1511. base::Value::Dict dict;
  1512. dict.Set("hello", "world");
  1513. values.emplace_back(std::move(dict));
  1514. base::Value::Dict dict2;
  1515. dict2.Set("world", "hello");
  1516. values.emplace_back(std::move(dict2));
  1517. base::Value::List list;
  1518. list.Append("hello");
  1519. list.Append("world");
  1520. values.emplace_back(std::move(list));
  1521. base::Value::List list2;
  1522. list2.Append("world");
  1523. list2.Append("hello");
  1524. values.emplace_back(std::move(list2));
  1525. for (const Value& outer_value : values) {
  1526. for (const Value& inner_value : values) {
  1527. SCOPED_TRACE(::testing::Message()
  1528. << "Outer: " << outer_value << "Inner: " << inner_value);
  1529. const bool should_be_equal = &outer_value == &inner_value;
  1530. if (should_be_equal) {
  1531. EXPECT_EQ(outer_value, inner_value);
  1532. EXPECT_EQ(inner_value, outer_value);
  1533. EXPECT_FALSE(outer_value != inner_value);
  1534. EXPECT_FALSE(inner_value != outer_value);
  1535. } else {
  1536. EXPECT_NE(outer_value, inner_value);
  1537. EXPECT_NE(inner_value, outer_value);
  1538. EXPECT_FALSE(outer_value == inner_value);
  1539. EXPECT_FALSE(inner_value == outer_value);
  1540. }
  1541. // Also test the various overloads for operator== against concrete
  1542. // subtypes.
  1543. outer_value.Visit([&](const auto& outer_member) {
  1544. using T = std::decay_t<decltype(outer_member)>;
  1545. if constexpr (!std::is_same_v<T, absl::monostate> &&
  1546. !std::is_same_v<T, Value::BlobStorage>) {
  1547. if (should_be_equal) {
  1548. EXPECT_EQ(outer_member, inner_value);
  1549. EXPECT_EQ(inner_value, outer_member);
  1550. EXPECT_FALSE(outer_member != inner_value);
  1551. EXPECT_FALSE(inner_value != outer_member);
  1552. } else {
  1553. EXPECT_NE(outer_member, inner_value);
  1554. EXPECT_NE(inner_value, outer_member);
  1555. EXPECT_FALSE(outer_member == inner_value);
  1556. EXPECT_FALSE(inner_value == outer_member);
  1557. }
  1558. }
  1559. });
  1560. }
  1561. // A copy of a Value should also compare equal to itself.
  1562. Value copied_value = outer_value.Clone();
  1563. EXPECT_EQ(outer_value, copied_value);
  1564. EXPECT_EQ(copied_value, outer_value);
  1565. EXPECT_FALSE(outer_value != copied_value);
  1566. EXPECT_FALSE(copied_value != outer_value);
  1567. }
  1568. }
  1569. // Test that a literal string comparison does not end up using the bool (!!)
  1570. // overload.
  1571. TEST(ValuesTest, LiteralStringEquals) {
  1572. EXPECT_EQ("hello world", base::Value("hello world"));
  1573. EXPECT_EQ(base::Value("hello world"), "hello world");
  1574. EXPECT_NE("hello world", base::Value(true));
  1575. EXPECT_NE(base::Value(true), "hello world");
  1576. }
  1577. TEST(ValuesTest, Equals) {
  1578. auto null1 = std::make_unique<Value>();
  1579. auto null2 = std::make_unique<Value>();
  1580. EXPECT_NE(null1.get(), null2.get());
  1581. EXPECT_EQ(*null1, *null2);
  1582. Value boolean(false);
  1583. EXPECT_NE(*null1, boolean);
  1584. DictionaryValue dv;
  1585. dv.SetBoolKey("a", false);
  1586. dv.SetIntKey("b", 2);
  1587. dv.SetDoubleKey("c", 2.5);
  1588. dv.SetStringKey("d1", "string");
  1589. dv.SetStringKey("d2", u"http://google.com");
  1590. dv.SetKey("e", Value());
  1591. auto copy = dv.CreateDeepCopy();
  1592. EXPECT_EQ(dv, *copy);
  1593. std::unique_ptr<ListValue> list(new ListValue);
  1594. list->Append(Value());
  1595. list->Append(Value(Value::Type::DICTIONARY));
  1596. Value list_copy(list->Clone());
  1597. ListValue* list_weak = dv.SetList("f", std::move(list));
  1598. EXPECT_NE(dv, *copy);
  1599. copy->SetKey("f", std::move(list_copy));
  1600. EXPECT_EQ(dv, *copy);
  1601. list_weak->Append(true);
  1602. EXPECT_NE(dv, *copy);
  1603. // Check if Equals detects differences in only the keys.
  1604. copy = dv.CreateDeepCopy();
  1605. EXPECT_EQ(dv, *copy);
  1606. copy->RemoveKey("a");
  1607. copy->SetBoolKey("aa", false);
  1608. EXPECT_NE(dv, *copy);
  1609. }
  1610. TEST(ValuesTest, Comparisons) {
  1611. // Test None Values.
  1612. Value null1;
  1613. Value null2;
  1614. EXPECT_EQ(null1, null2);
  1615. EXPECT_FALSE(null1 != null2);
  1616. EXPECT_FALSE(null1 < null2);
  1617. EXPECT_FALSE(null1 > null2);
  1618. EXPECT_LE(null1, null2);
  1619. EXPECT_GE(null1, null2);
  1620. // Test Bool Values.
  1621. Value bool1(false);
  1622. Value bool2(true);
  1623. EXPECT_FALSE(bool1 == bool2);
  1624. EXPECT_NE(bool1, bool2);
  1625. EXPECT_LT(bool1, bool2);
  1626. EXPECT_FALSE(bool1 > bool2);
  1627. EXPECT_LE(bool1, bool2);
  1628. EXPECT_FALSE(bool1 >= bool2);
  1629. // Test Int Values.
  1630. Value int1(1);
  1631. Value int2(2);
  1632. EXPECT_FALSE(int1 == int2);
  1633. EXPECT_NE(int1, int2);
  1634. EXPECT_LT(int1, int2);
  1635. EXPECT_FALSE(int1 > int2);
  1636. EXPECT_LE(int1, int2);
  1637. EXPECT_FALSE(int1 >= int2);
  1638. // Test Double Values.
  1639. Value double1(1.0);
  1640. Value double2(2.0);
  1641. EXPECT_FALSE(double1 == double2);
  1642. EXPECT_NE(double1, double2);
  1643. EXPECT_LT(double1, double2);
  1644. EXPECT_FALSE(double1 > double2);
  1645. EXPECT_LE(double1, double2);
  1646. EXPECT_FALSE(double1 >= double2);
  1647. // Test String Values.
  1648. Value string1("1");
  1649. Value string2("2");
  1650. EXPECT_FALSE(string1 == string2);
  1651. EXPECT_NE(string1, string2);
  1652. EXPECT_LT(string1, string2);
  1653. EXPECT_FALSE(string1 > string2);
  1654. EXPECT_LE(string1, string2);
  1655. EXPECT_FALSE(string1 >= string2);
  1656. // Test Binary Values.
  1657. Value binary1(Value::BlobStorage{0x01});
  1658. Value binary2(Value::BlobStorage{0x02});
  1659. EXPECT_FALSE(binary1 == binary2);
  1660. EXPECT_NE(binary1, binary2);
  1661. EXPECT_LT(binary1, binary2);
  1662. EXPECT_FALSE(binary1 > binary2);
  1663. EXPECT_LE(binary1, binary2);
  1664. EXPECT_FALSE(binary1 >= binary2);
  1665. // Test Empty List Values.
  1666. ListValue null_list1;
  1667. ListValue null_list2;
  1668. EXPECT_EQ(null_list1, null_list2);
  1669. EXPECT_FALSE(null_list1 != null_list2);
  1670. EXPECT_FALSE(null_list1 < null_list2);
  1671. EXPECT_FALSE(null_list1 > null_list2);
  1672. EXPECT_LE(null_list1, null_list2);
  1673. EXPECT_GE(null_list1, null_list2);
  1674. // Test Non Empty List Values.
  1675. ListValue int_list1;
  1676. ListValue int_list2;
  1677. int_list1.Append(1);
  1678. int_list2.Append(2);
  1679. EXPECT_FALSE(int_list1 == int_list2);
  1680. EXPECT_NE(int_list1, int_list2);
  1681. EXPECT_LT(int_list1, int_list2);
  1682. EXPECT_FALSE(int_list1 > int_list2);
  1683. EXPECT_LE(int_list1, int_list2);
  1684. EXPECT_FALSE(int_list1 >= int_list2);
  1685. // Test Empty Dict Values.
  1686. DictionaryValue null_dict1;
  1687. DictionaryValue null_dict2;
  1688. EXPECT_EQ(null_dict1, null_dict2);
  1689. EXPECT_FALSE(null_dict1 != null_dict2);
  1690. EXPECT_FALSE(null_dict1 < null_dict2);
  1691. EXPECT_FALSE(null_dict1 > null_dict2);
  1692. EXPECT_LE(null_dict1, null_dict2);
  1693. EXPECT_GE(null_dict1, null_dict2);
  1694. // Test Non Empty Dict Values.
  1695. DictionaryValue int_dict1;
  1696. DictionaryValue int_dict2;
  1697. int_dict1.SetIntKey("key", 1);
  1698. int_dict2.SetIntKey("key", 2);
  1699. EXPECT_FALSE(int_dict1 == int_dict2);
  1700. EXPECT_NE(int_dict1, int_dict2);
  1701. EXPECT_LT(int_dict1, int_dict2);
  1702. EXPECT_FALSE(int_dict1 > int_dict2);
  1703. EXPECT_LE(int_dict1, int_dict2);
  1704. EXPECT_FALSE(int_dict1 >= int_dict2);
  1705. // Test Values of different types.
  1706. std::vector<Value> values;
  1707. values.emplace_back(std::move(null1));
  1708. values.emplace_back(std::move(bool1));
  1709. values.emplace_back(std::move(int1));
  1710. values.emplace_back(std::move(double1));
  1711. values.emplace_back(std::move(string1));
  1712. values.emplace_back(std::move(binary1));
  1713. values.emplace_back(std::move(int_dict1));
  1714. values.emplace_back(std::move(int_list1));
  1715. for (size_t i = 0; i < values.size(); ++i) {
  1716. for (size_t j = i + 1; j < values.size(); ++j) {
  1717. EXPECT_FALSE(values[i] == values[j]);
  1718. EXPECT_NE(values[i], values[j]);
  1719. EXPECT_LT(values[i], values[j]);
  1720. EXPECT_FALSE(values[i] > values[j]);
  1721. EXPECT_LE(values[i], values[j]);
  1722. EXPECT_FALSE(values[i] >= values[j]);
  1723. }
  1724. }
  1725. }
  1726. TEST(ValuesTest, DeepCopyCovariantReturnTypes) {
  1727. DictionaryValue original_dict;
  1728. Value* null_weak = original_dict.SetKey("null", Value());
  1729. Value* bool_weak = original_dict.SetKey("bool", Value(true));
  1730. Value* int_weak = original_dict.SetKey("int", Value(42));
  1731. Value* double_weak = original_dict.SetKey("double", Value(3.14));
  1732. Value* string_weak = original_dict.SetKey("string", Value("hello"));
  1733. Value* string16_weak = original_dict.SetKey("string16", Value(u"hello16"));
  1734. Value* binary_weak =
  1735. original_dict.SetKey("binary", Value(Value::BlobStorage(42, '!')));
  1736. Value::List list;
  1737. list.Append(0);
  1738. list.Append(1);
  1739. Value* list_weak = original_dict.SetKey("list", Value(std::move(list)));
  1740. auto copy_dict = std::make_unique<Value>(original_dict.Clone());
  1741. auto copy_null = std::make_unique<Value>(null_weak->Clone());
  1742. auto copy_bool = std::make_unique<Value>(bool_weak->Clone());
  1743. auto copy_int = std::make_unique<Value>(int_weak->Clone());
  1744. auto copy_double = std::make_unique<Value>(double_weak->Clone());
  1745. auto copy_string = std::make_unique<Value>(string_weak->Clone());
  1746. auto copy_string16 = std::make_unique<Value>(string16_weak->Clone());
  1747. auto copy_binary = std::make_unique<Value>(binary_weak->Clone());
  1748. auto copy_list = std::make_unique<Value>(list_weak->Clone());
  1749. EXPECT_EQ(original_dict, *copy_dict);
  1750. EXPECT_EQ(*null_weak, *copy_null);
  1751. EXPECT_EQ(*bool_weak, *copy_bool);
  1752. EXPECT_EQ(*int_weak, *copy_int);
  1753. EXPECT_EQ(*double_weak, *copy_double);
  1754. EXPECT_EQ(*string_weak, *copy_string);
  1755. EXPECT_EQ(*string16_weak, *copy_string16);
  1756. EXPECT_EQ(*binary_weak, *copy_binary);
  1757. EXPECT_EQ(*list_weak, *copy_list);
  1758. }
  1759. TEST(ValuesTest, MergeDictionary) {
  1760. std::unique_ptr<DictionaryValue> base(new DictionaryValue);
  1761. base->SetStringKey("base_key", "base_key_value_base");
  1762. base->SetStringKey("collide_key", "collide_key_value_base");
  1763. DictionaryValue base_sub_dict;
  1764. base_sub_dict.SetStringKey("sub_base_key", "sub_base_key_value_base");
  1765. base_sub_dict.SetStringKey("sub_collide_key", "sub_collide_key_value_base");
  1766. base->SetKey("sub_dict_key", std::move(base_sub_dict));
  1767. std::unique_ptr<DictionaryValue> merge(new DictionaryValue);
  1768. merge->SetStringKey("merge_key", "merge_key_value_merge");
  1769. merge->SetStringKey("collide_key", "collide_key_value_merge");
  1770. DictionaryValue merge_sub_dict;
  1771. merge_sub_dict.SetStringKey("sub_merge_key", "sub_merge_key_value_merge");
  1772. merge_sub_dict.SetStringKey("sub_collide_key", "sub_collide_key_value_merge");
  1773. merge->SetKey("sub_dict_key", std::move(merge_sub_dict));
  1774. base->MergeDictionary(merge.get());
  1775. EXPECT_EQ(4U, base->DictSize());
  1776. std::string base_key_value;
  1777. EXPECT_TRUE(base->GetString("base_key", &base_key_value));
  1778. EXPECT_EQ("base_key_value_base", base_key_value); // Base value preserved.
  1779. std::string collide_key_value;
  1780. EXPECT_TRUE(base->GetString("collide_key", &collide_key_value));
  1781. EXPECT_EQ("collide_key_value_merge", collide_key_value); // Replaced.
  1782. std::string merge_key_value;
  1783. EXPECT_TRUE(base->GetString("merge_key", &merge_key_value));
  1784. EXPECT_EQ("merge_key_value_merge", merge_key_value); // Merged in.
  1785. DictionaryValue* res_sub_dict;
  1786. EXPECT_TRUE(base->GetDictionary("sub_dict_key", &res_sub_dict));
  1787. EXPECT_EQ(3U, res_sub_dict->DictSize());
  1788. std::string sub_base_key_value;
  1789. EXPECT_TRUE(res_sub_dict->GetString("sub_base_key", &sub_base_key_value));
  1790. EXPECT_EQ("sub_base_key_value_base", sub_base_key_value); // Preserved.
  1791. std::string sub_collide_key_value;
  1792. EXPECT_TRUE(
  1793. res_sub_dict->GetString("sub_collide_key", &sub_collide_key_value));
  1794. EXPECT_EQ("sub_collide_key_value_merge", sub_collide_key_value); // Replaced.
  1795. std::string sub_merge_key_value;
  1796. EXPECT_TRUE(res_sub_dict->GetString("sub_merge_key", &sub_merge_key_value));
  1797. EXPECT_EQ("sub_merge_key_value_merge", sub_merge_key_value); // Merged in.
  1798. }
  1799. TEST(ValuesTest, MergeDictionaryDeepCopy) {
  1800. std::unique_ptr<DictionaryValue> child(new DictionaryValue);
  1801. DictionaryValue* original_child = child.get();
  1802. child->SetStringKey("test", "value");
  1803. EXPECT_EQ(1U, child->DictSize());
  1804. std::string value;
  1805. EXPECT_TRUE(child->GetString("test", &value));
  1806. EXPECT_EQ("value", value);
  1807. std::unique_ptr<DictionaryValue> base(new DictionaryValue);
  1808. base->Set("dict", std::move(child));
  1809. EXPECT_EQ(1U, base->DictSize());
  1810. DictionaryValue* ptr;
  1811. EXPECT_TRUE(base->GetDictionary("dict", &ptr));
  1812. EXPECT_EQ(original_child, ptr);
  1813. std::unique_ptr<DictionaryValue> merged(new DictionaryValue);
  1814. merged->MergeDictionary(base.get());
  1815. EXPECT_EQ(1U, merged->DictSize());
  1816. EXPECT_TRUE(merged->GetDictionary("dict", &ptr));
  1817. EXPECT_NE(original_child, ptr);
  1818. EXPECT_TRUE(ptr->GetString("test", &value));
  1819. EXPECT_EQ("value", value);
  1820. original_child->SetStringKey("test", "overwrite");
  1821. base.reset();
  1822. EXPECT_TRUE(ptr->GetString("test", &value));
  1823. EXPECT_EQ("value", value);
  1824. }
  1825. TEST(ValuesTest, DictionaryIterator) {
  1826. DictionaryValue dict;
  1827. for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
  1828. ADD_FAILURE();
  1829. }
  1830. Value value1("value1");
  1831. dict.SetKey("key1", value1.Clone());
  1832. bool seen1 = false;
  1833. for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
  1834. EXPECT_FALSE(seen1);
  1835. EXPECT_EQ("key1", it.key());
  1836. EXPECT_EQ(value1, it.value());
  1837. seen1 = true;
  1838. }
  1839. EXPECT_TRUE(seen1);
  1840. Value value2("value2");
  1841. dict.SetKey("key2", value2.Clone());
  1842. bool seen2 = seen1 = false;
  1843. for (DictionaryValue::Iterator it(dict); !it.IsAtEnd(); it.Advance()) {
  1844. if (it.key() == "key1") {
  1845. EXPECT_FALSE(seen1);
  1846. EXPECT_EQ(value1, it.value());
  1847. seen1 = true;
  1848. } else if (it.key() == "key2") {
  1849. EXPECT_FALSE(seen2);
  1850. EXPECT_EQ(value2, it.value());
  1851. seen2 = true;
  1852. } else {
  1853. ADD_FAILURE();
  1854. }
  1855. }
  1856. EXPECT_TRUE(seen1);
  1857. EXPECT_TRUE(seen2);
  1858. }
  1859. TEST(ValuesTest, MutatingCopiedPairsInDictItemsMutatesUnderlyingValues) {
  1860. Value dict(Value::Type::DICTIONARY);
  1861. dict.SetKey("key", Value("initial value"));
  1862. // Because the non-const DictItems() iterates over
  1863. // <const std::string&, Value&> pairs, it's possible
  1864. // to alter iterated-over values in place even when
  1865. // "copying" the key-value pair:
  1866. for (auto kv : dict.DictItems())
  1867. kv.second.GetString() = "replacement";
  1868. std::string* found = dict.FindStringKey("key");
  1869. ASSERT_TRUE(found);
  1870. EXPECT_EQ(*found, "replacement");
  1871. }
  1872. TEST(ValuesTest, StdDictionaryIterator) {
  1873. DictionaryValue dict;
  1874. for (auto it = dict.DictItems().begin(); it != dict.DictItems().end(); ++it) {
  1875. ADD_FAILURE();
  1876. }
  1877. Value value1("value1");
  1878. dict.SetKey("key1", value1.Clone());
  1879. bool seen1 = false;
  1880. for (auto it : dict.DictItems()) {
  1881. EXPECT_FALSE(seen1);
  1882. EXPECT_EQ("key1", it.first);
  1883. EXPECT_EQ(value1, it.second);
  1884. seen1 = true;
  1885. }
  1886. EXPECT_TRUE(seen1);
  1887. Value value2("value2");
  1888. dict.SetKey("key2", value2.Clone());
  1889. bool seen2 = seen1 = false;
  1890. for (auto it : dict.DictItems()) {
  1891. if (it.first == "key1") {
  1892. EXPECT_FALSE(seen1);
  1893. EXPECT_EQ(value1, it.second);
  1894. seen1 = true;
  1895. } else if (it.first == "key2") {
  1896. EXPECT_FALSE(seen2);
  1897. EXPECT_EQ(value2, it.second);
  1898. seen2 = true;
  1899. } else {
  1900. ADD_FAILURE();
  1901. }
  1902. }
  1903. EXPECT_TRUE(seen1);
  1904. EXPECT_TRUE(seen2);
  1905. }
  1906. // DictionaryValue/ListValue's Get*() methods should accept NULL as an out-value
  1907. // and still return true/false based on success.
  1908. TEST(ValuesTest, GetWithNullOutValue) {
  1909. DictionaryValue main_dict;
  1910. ListValue main_list;
  1911. Value bool_value(false);
  1912. Value int_value(1234);
  1913. Value double_value(12.34567);
  1914. Value string_value("foo");
  1915. Value binary_value(Value::Type::BINARY);
  1916. DictionaryValue dict_value;
  1917. ListValue list_value;
  1918. main_dict.SetKey("bool", bool_value.Clone());
  1919. main_dict.SetKey("int", int_value.Clone());
  1920. main_dict.SetKey("double", double_value.Clone());
  1921. main_dict.SetKey("string", string_value.Clone());
  1922. main_dict.SetKey("binary", binary_value.Clone());
  1923. main_dict.SetKey("dict", dict_value.Clone());
  1924. main_dict.SetKey("list", list_value.Clone());
  1925. main_list.Append(bool_value.Clone());
  1926. main_list.Append(int_value.Clone());
  1927. main_list.Append(double_value.Clone());
  1928. main_list.Append(string_value.Clone());
  1929. main_list.Append(binary_value.Clone());
  1930. main_list.Append(dict_value.Clone());
  1931. main_list.Append(list_value.Clone());
  1932. EXPECT_TRUE(main_dict.Get("bool", nullptr));
  1933. EXPECT_TRUE(main_dict.Get("int", nullptr));
  1934. EXPECT_TRUE(main_dict.Get("double", nullptr));
  1935. EXPECT_TRUE(main_dict.Get("string", nullptr));
  1936. EXPECT_TRUE(main_dict.Get("binary", nullptr));
  1937. EXPECT_TRUE(main_dict.Get("dict", nullptr));
  1938. EXPECT_TRUE(main_dict.Get("list", nullptr));
  1939. EXPECT_FALSE(main_dict.Get("DNE", nullptr));
  1940. EXPECT_FALSE(main_dict.GetInteger("bool", nullptr));
  1941. EXPECT_TRUE(main_dict.GetInteger("int", nullptr));
  1942. EXPECT_FALSE(main_dict.GetInteger("double", nullptr));
  1943. EXPECT_FALSE(main_dict.GetInteger("string", nullptr));
  1944. EXPECT_FALSE(main_dict.GetInteger("binary", nullptr));
  1945. EXPECT_FALSE(main_dict.GetInteger("dict", nullptr));
  1946. EXPECT_FALSE(main_dict.GetInteger("list", nullptr));
  1947. EXPECT_FALSE(main_dict.GetInteger("DNE", nullptr));
  1948. EXPECT_FALSE(main_dict.GetString("bool", static_cast<std::string*>(nullptr)));
  1949. EXPECT_FALSE(main_dict.GetString("int", static_cast<std::string*>(nullptr)));
  1950. EXPECT_FALSE(
  1951. main_dict.GetString("double", static_cast<std::string*>(nullptr)));
  1952. EXPECT_TRUE(
  1953. main_dict.GetString("string", static_cast<std::string*>(nullptr)));
  1954. EXPECT_FALSE(
  1955. main_dict.GetString("binary", static_cast<std::string*>(nullptr)));
  1956. EXPECT_FALSE(main_dict.GetString("dict", static_cast<std::string*>(nullptr)));
  1957. EXPECT_FALSE(main_dict.GetString("list", static_cast<std::string*>(nullptr)));
  1958. EXPECT_FALSE(main_dict.GetString("DNE", static_cast<std::string*>(nullptr)));
  1959. EXPECT_FALSE(main_dict.GetDictionary("bool", nullptr));
  1960. EXPECT_FALSE(main_dict.GetDictionary("int", nullptr));
  1961. EXPECT_FALSE(main_dict.GetDictionary("double", nullptr));
  1962. EXPECT_FALSE(main_dict.GetDictionary("string", nullptr));
  1963. EXPECT_FALSE(main_dict.GetDictionary("binary", nullptr));
  1964. EXPECT_TRUE(main_dict.GetDictionary("dict", nullptr));
  1965. EXPECT_FALSE(main_dict.GetDictionary("list", nullptr));
  1966. EXPECT_FALSE(main_dict.GetDictionary("DNE", nullptr));
  1967. EXPECT_FALSE(main_dict.GetList("bool", nullptr));
  1968. EXPECT_FALSE(main_dict.GetList("int", nullptr));
  1969. EXPECT_FALSE(main_dict.GetList("double", nullptr));
  1970. EXPECT_FALSE(main_dict.GetList("string", nullptr));
  1971. EXPECT_FALSE(main_dict.GetList("binary", nullptr));
  1972. EXPECT_FALSE(main_dict.GetList("dict", nullptr));
  1973. EXPECT_TRUE(main_dict.GetList("list", nullptr));
  1974. EXPECT_FALSE(main_dict.GetList("DNE", nullptr));
  1975. }
  1976. TEST(ValuesTest, SelfSwap) {
  1977. base::Value test(1);
  1978. std::swap(test, test);
  1979. EXPECT_EQ(1, test.GetInt());
  1980. }
  1981. TEST(ValuesTest, FromToUniquePtrValue) {
  1982. std::unique_ptr<DictionaryValue> dict = std::make_unique<DictionaryValue>();
  1983. dict->SetStringKey("name", "Froogle");
  1984. dict->SetStringKey("url", "http://froogle.com");
  1985. Value dict_copy = dict->Clone();
  1986. Value dict_converted = Value::FromUniquePtrValue(std::move(dict));
  1987. EXPECT_EQ(dict_copy, dict_converted);
  1988. std::unique_ptr<Value> val =
  1989. Value::ToUniquePtrValue(std::move(dict_converted));
  1990. EXPECT_EQ(dict_copy, *val);
  1991. }
  1992. TEST(ValuesTest, MutableFindStringPath) {
  1993. Value dict(Value::Type::DICTIONARY);
  1994. dict.SetStringPath("foo.bar", "value");
  1995. *(dict.FindStringPath("foo.bar")) = "new_value";
  1996. Value expected_dict(Value::Type::DICTIONARY);
  1997. expected_dict.SetStringPath("foo.bar", "new_value");
  1998. EXPECT_EQ(expected_dict, dict);
  1999. }
  2000. TEST(ValuesTest, MutableGetString) {
  2001. Value value("value");
  2002. value.GetString() = "new_value";
  2003. EXPECT_EQ("new_value", value.GetString());
  2004. }
  2005. #if BUILDFLAG(ENABLE_BASE_TRACING)
  2006. TEST(ValuesTest, TracingSupport) {
  2007. EXPECT_EQ(perfetto::TracedValueToString(Value(false)), "false");
  2008. EXPECT_EQ(perfetto::TracedValueToString(Value(1)), "1");
  2009. EXPECT_EQ(perfetto::TracedValueToString(Value(1.5)), "1.5");
  2010. EXPECT_EQ(perfetto::TracedValueToString(Value("value")), "value");
  2011. EXPECT_EQ(perfetto::TracedValueToString(Value(Value::Type::NONE)), "<none>");
  2012. {
  2013. Value::List list;
  2014. EXPECT_EQ(perfetto::TracedValueToString(list), "{}");
  2015. list.Append(2);
  2016. list.Append(3);
  2017. EXPECT_EQ(perfetto::TracedValueToString(list), "[2,3]");
  2018. EXPECT_EQ(perfetto::TracedValueToString(Value(std::move(list))), "[2,3]");
  2019. }
  2020. {
  2021. Value::Dict dict;
  2022. EXPECT_EQ(perfetto::TracedValueToString(dict), "{}");
  2023. dict.Set("key", "value");
  2024. EXPECT_EQ(perfetto::TracedValueToString(dict), "{key:value}");
  2025. EXPECT_EQ(perfetto::TracedValueToString(Value(std::move(dict))),
  2026. "{key:value}");
  2027. }
  2028. }
  2029. #endif // BUILDFLAG(ENABLE_BASE_TRACING)
  2030. TEST(ValueViewTest, BasicConstruction) {
  2031. {
  2032. ValueView v = true;
  2033. EXPECT_EQ(true, absl::get<bool>(v.data_view_for_test()));
  2034. }
  2035. {
  2036. ValueView v = 25;
  2037. EXPECT_EQ(25, absl::get<int>(v.data_view_for_test()));
  2038. }
  2039. {
  2040. ValueView v = 3.14;
  2041. EXPECT_DOUBLE_EQ(3.14, absl::get<ValueView::DoubleStorageForTest>(
  2042. v.data_view_for_test()));
  2043. }
  2044. {
  2045. ValueView v = StringPiece("hello world");
  2046. EXPECT_EQ("hello world", absl::get<StringPiece>(v.data_view_for_test()));
  2047. }
  2048. {
  2049. ValueView v = "hello world";
  2050. EXPECT_EQ("hello world", absl::get<StringPiece>(v.data_view_for_test()));
  2051. }
  2052. {
  2053. std::string str = "hello world";
  2054. ValueView v = str;
  2055. EXPECT_EQ("hello world", absl::get<StringPiece>(v.data_view_for_test()));
  2056. }
  2057. {
  2058. Value::Dict dict;
  2059. dict.Set("hello", "world");
  2060. ValueView v = dict;
  2061. EXPECT_EQ(dict, absl::get<std::reference_wrapper<const Value::Dict>>(
  2062. v.data_view_for_test()));
  2063. }
  2064. {
  2065. Value::List list;
  2066. list.Append("hello");
  2067. list.Append("world");
  2068. ValueView v = list;
  2069. EXPECT_EQ(list, absl::get<std::reference_wrapper<const Value::List>>(
  2070. v.data_view_for_test()));
  2071. }
  2072. }
  2073. TEST(ValueViewTest, ValueConstruction) {
  2074. {
  2075. Value val(true);
  2076. ValueView v = val;
  2077. EXPECT_EQ(true, absl::get<bool>(v.data_view_for_test()));
  2078. }
  2079. {
  2080. Value val(25);
  2081. ValueView v = val;
  2082. EXPECT_EQ(25, absl::get<int>(v.data_view_for_test()));
  2083. }
  2084. {
  2085. Value val(3.14);
  2086. ValueView v = val;
  2087. EXPECT_DOUBLE_EQ(3.14, absl::get<ValueView::DoubleStorageForTest>(
  2088. v.data_view_for_test()));
  2089. }
  2090. {
  2091. Value val("hello world");
  2092. ValueView v = val;
  2093. EXPECT_EQ("hello world", absl::get<StringPiece>(v.data_view_for_test()));
  2094. }
  2095. {
  2096. Value::Dict dict;
  2097. dict.Set("hello", "world");
  2098. Value val(dict.Clone());
  2099. ValueView v = val;
  2100. EXPECT_EQ(dict, absl::get<std::reference_wrapper<const Value::Dict>>(
  2101. v.data_view_for_test()));
  2102. }
  2103. {
  2104. Value::List list;
  2105. list.Append("hello");
  2106. list.Append("world");
  2107. Value val(list.Clone());
  2108. ValueView v = val;
  2109. EXPECT_EQ(list, absl::get<std::reference_wrapper<const Value::List>>(
  2110. v.data_view_for_test()));
  2111. }
  2112. }
  2113. TEST(ValueViewTest, ToValue) {
  2114. {
  2115. Value val(true);
  2116. Value to_val = ValueView(val).ToValue();
  2117. EXPECT_EQ(val, to_val);
  2118. }
  2119. {
  2120. Value val(25);
  2121. Value to_val = ValueView(val).ToValue();
  2122. EXPECT_EQ(val, to_val);
  2123. }
  2124. {
  2125. Value val(3.14);
  2126. Value to_val = ValueView(val).ToValue();
  2127. EXPECT_EQ(val, to_val);
  2128. }
  2129. {
  2130. Value val("hello world");
  2131. Value to_val = ValueView(val).ToValue();
  2132. EXPECT_EQ(val, to_val);
  2133. }
  2134. {
  2135. Value::Dict dict;
  2136. dict.Set("hello", "world");
  2137. Value val(dict.Clone());
  2138. Value to_val = ValueView(val).ToValue();
  2139. EXPECT_EQ(val, to_val);
  2140. }
  2141. {
  2142. Value::List list;
  2143. list.Append("hello");
  2144. list.Append("world");
  2145. Value val(list.Clone());
  2146. Value to_val = ValueView(val).ToValue();
  2147. EXPECT_EQ(val, to_val);
  2148. }
  2149. }
  2150. } // namespace base