Movatterモバイル変換

[0]ホーム
URL:

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