base_type_conversion_unittest.cc 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257
  1. // Copyright 2019 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "ui/base/metadata/base_type_conversion.h"
  5. #include "base/ranges/ranges.h"
  6. #include "base/strings/string_tokenizer.h"
  7. #include "base/strings/utf_string_conversions.h"
  8. #include "testing/gtest/include/gtest/gtest.h"
  9. #include "testing/platform_test.h"
  10. #include "ui/gfx/geometry/insets.h"
  11. #include "ui/gfx/geometry/rect.h"
  12. using TypeConversionTest = PlatformTest;
  13. // Used in CheckIsSerializable test case.
  14. enum TestResult {
  15. TEST_TRUE,
  16. TEST_FALSE,
  17. };
  18. DEFINE_ENUM_CONVERTERS(TestResult, {TEST_TRUE, u"TRUE"}, {TEST_FALSE, u"FALSE"})
  19. TEST_F(TypeConversionTest, TestConversion_IntToString) {
  20. int from_int = 5;
  21. std::u16string to_string =
  22. ui::metadata::TypeConverter<int>::ToString(from_int);
  23. EXPECT_EQ(to_string, u"5");
  24. }
  25. TEST_F(TypeConversionTest, TestConversion_StringToInt) {
  26. std::u16string from_string = u"10";
  27. EXPECT_EQ(ui::metadata::TypeConverter<int>::FromString(from_string), 10);
  28. }
  29. // This tests whether the converter handles a bogus input string, in which case
  30. // the return value should be nullopt.
  31. TEST_F(TypeConversionTest, TestConversion_BogusStringToInt) {
  32. std::u16string from_string = u"Foo";
  33. EXPECT_EQ(ui::metadata::TypeConverter<int>::FromString(from_string),
  34. absl::nullopt);
  35. }
  36. TEST_F(TypeConversionTest, TestConversion_BogusStringToFloat) {
  37. std::u16string from_string = u"1.2";
  38. EXPECT_EQ(ui::metadata::TypeConverter<float>::FromString(from_string), 1.2f);
  39. }
  40. TEST_F(TypeConversionTest, TestConversion_OptionalIntToString) {
  41. absl::optional<int> src;
  42. std::u16string to_string =
  43. ui::metadata::TypeConverter<absl::optional<int>>::ToString(src);
  44. EXPECT_EQ(to_string, ui::metadata::GetNullOptStr());
  45. src = 5;
  46. to_string = ui::metadata::TypeConverter<absl::optional<int>>::ToString(src);
  47. EXPECT_EQ(to_string, u"5");
  48. }
  49. TEST_F(TypeConversionTest, TestConversion_StringToOptionalInt) {
  50. absl::optional<int> ret;
  51. EXPECT_EQ(ui::metadata::TypeConverter<absl::optional<int>>::FromString(
  52. ui::metadata::GetNullOptStr()),
  53. absl::make_optional(ret));
  54. EXPECT_EQ(ui::metadata::TypeConverter<absl::optional<int>>::FromString(u"10"),
  55. 10);
  56. EXPECT_EQ(
  57. ui::metadata::TypeConverter<absl::optional<int>>::FromString(u"ab0"),
  58. absl::nullopt);
  59. }
  60. TEST_F(TypeConversionTest, TestConversion_ShadowValuesToString) {
  61. gfx::ShadowValues shadow_values;
  62. shadow_values.emplace_back(gfx::Vector2d(1, 2), .3,
  63. SkColorSetARGB(128, 255, 0, 0));
  64. EXPECT_EQ(
  65. ui::metadata::TypeConverter<gfx::ShadowValues>::ToString(shadow_values),
  66. u"[ (1,2),0.30,rgba(255,0,0,128) ]");
  67. shadow_values.emplace_back(gfx::Vector2d(9, 8), .76,
  68. SkColorSetARGB(20, 0, 64, 255));
  69. EXPECT_EQ(
  70. ui::metadata::TypeConverter<gfx::ShadowValues>::ToString(shadow_values),
  71. u"[ (1,2),0.30,rgba(255,0,0,128); (9,8),0.76,rgba(0,64,255,20) ]");
  72. }
  73. TEST_F(TypeConversionTest, TestConversion_StringToShadowValues) {
  74. absl::optional<gfx::ShadowValues> opt_result =
  75. ui::metadata::TypeConverter<gfx::ShadowValues>::FromString(
  76. u"[ (6,4),0.53,rgba(23,44,0,1); (93,83),4.33,rgba(10,20,0,0.059) ]");
  77. EXPECT_EQ(opt_result.has_value(), true);
  78. gfx::ShadowValues result = opt_result.value();
  79. EXPECT_EQ(result.size(), 2U);
  80. EXPECT_EQ(result[0].color(), SkColorSetARGB(255, 23, 44, 0));
  81. EXPECT_EQ(result[1].color(), SkColorSetARGB(15, 10, 20, 0));
  82. EXPECT_EQ(result[0].x(), 6);
  83. EXPECT_EQ(result[1].x(), 93);
  84. EXPECT_EQ(result[0].y(), 4);
  85. EXPECT_EQ(result[1].y(), 83);
  86. EXPECT_EQ(result[0].blur(), 0.53);
  87. EXPECT_EQ(result[1].blur(), 4.33);
  88. }
  89. TEST_F(TypeConversionTest, TestConversion_SkColorConversions) {
  90. // Check conversion from rgb hex string
  91. absl::optional<SkColor> result =
  92. ui::metadata::SkColorConverter::FromString(u"0x112233");
  93. EXPECT_TRUE(result);
  94. EXPECT_EQ(result.value(), SkColorSetRGB(0x11, 0x22, 0x33));
  95. // Check conversion from argb hex string
  96. result = ui::metadata::SkColorConverter::FromString(u"0x7F112233");
  97. EXPECT_TRUE(result);
  98. EXPECT_EQ(result.value(), SkColorSetARGB(0x7F, 0x11, 0x22, 0x33));
  99. // Check conversion from rgb(r,g,b) string
  100. result = ui::metadata::SkColorConverter::FromString(u"rgb(0, 128, 192)");
  101. EXPECT_TRUE(result);
  102. EXPECT_EQ(result.value(), SkColorSetRGB(0, 128, 192));
  103. // Check conversion from rgba(r,g,b,a) string
  104. result =
  105. ui::metadata::SkColorConverter::FromString(u"rgba(0, 128, 192, 0.5)");
  106. EXPECT_TRUE(result);
  107. EXPECT_EQ(result.value(), SkColorSetARGB(128, 0, 128, 192));
  108. // Check conversion from hsl(h,s,l) string
  109. result = ui::metadata::SkColorConverter::FromString(u"hsl(195, 100%, 50%)");
  110. EXPECT_TRUE(result);
  111. const SkScalar hsv[3] = {195.0, 1.0, 0.5};
  112. EXPECT_EQ(result.value(), SkHSVToColor(hsv));
  113. // Check conversion from hsla(h,s,l,a) string
  114. result =
  115. ui::metadata::SkColorConverter::FromString(u"hsl(195, 100%, 50%, 0.5)");
  116. EXPECT_TRUE(result);
  117. EXPECT_EQ(result.value(), SkHSVToColor(128, hsv));
  118. // Check conversion from a decimal integer value
  119. result = ui::metadata::SkColorConverter::FromString(u"4278239231");
  120. EXPECT_TRUE(result);
  121. EXPECT_EQ(result.value(), SkColorSetARGB(255, 0, 191, 255));
  122. // Check without commas.
  123. result = ui::metadata::SkColorConverter::FromString(u"rgba(92 92 92 1)");
  124. EXPECT_TRUE(result);
  125. EXPECT_EQ(result.value(), SkColorSetARGB(255, 92, 92, 92));
  126. // Don't support the CSS hash color style
  127. result = ui::metadata::SkColorConverter::FromString(u"#03254");
  128. EXPECT_FALSE(result);
  129. // Don't support some common invalid values
  130. result = ui::metadata::SkColorConverter::FromString(u"rgba(1,2,3,4)");
  131. EXPECT_FALSE(result);
  132. result = ui::metadata::SkColorConverter::FromString(u"rgba(1,2,3,4");
  133. EXPECT_FALSE(result);
  134. result = ui::metadata::SkColorConverter::FromString(u"hsla(1,2,3,4)");
  135. EXPECT_FALSE(result);
  136. }
  137. TEST_F(TypeConversionTest, TestConversion_ColorParserTest) {
  138. using converter = ui::metadata::SkColorConverter;
  139. std::u16string color;
  140. const std::u16string source =
  141. u"rgb(0, 128, 192), hsl(90, 100%, 30%), rgba(128, 128, 128, 0.5), "
  142. u"hsla(240, 100%, 50%, 0.5)";
  143. auto start_pos = source.cbegin();
  144. EXPECT_TRUE(
  145. converter::GetNextColor(start_pos, source.cend(), color, start_pos));
  146. EXPECT_EQ(color, u"rgb(0, 128, 192)");
  147. EXPECT_TRUE(
  148. converter::GetNextColor(start_pos, source.cend(), color, start_pos));
  149. EXPECT_EQ(color, u"hsl(90, 100%, 30%)");
  150. EXPECT_TRUE(
  151. converter::GetNextColor(start_pos, source.cend(), color, start_pos));
  152. EXPECT_EQ(color, u"rgba(128, 128, 128, 0.5)");
  153. EXPECT_TRUE(converter::GetNextColor(start_pos, source.cend(), color));
  154. EXPECT_EQ(color, u"hsla(240, 100%, 50%, 0.5)");
  155. }
  156. TEST_F(TypeConversionTest, TestConversion_InsetsToString) {
  157. constexpr auto kInsets = gfx::Insets::TLBR(3, 5, 7, 9);
  158. std::u16string to_string =
  159. ui::metadata::TypeConverter<gfx::Insets>::ToString(kInsets);
  160. EXPECT_EQ(to_string, u"3,5,7,9");
  161. }
  162. TEST_F(TypeConversionTest, TestConversion_StringToInsets) {
  163. std::u16string from_string = u"2,3,4,5";
  164. EXPECT_EQ(ui::metadata::TypeConverter<gfx::Insets>::FromString(from_string),
  165. gfx::Insets::TLBR(2, 3, 4, 5));
  166. }
  167. TEST_F(TypeConversionTest, TestConversion_VectorToString) {
  168. const std::vector<int> kVector{3, 5, 7, 9};
  169. std::u16string to_string =
  170. ui::metadata::TypeConverter<std::vector<int>>::ToString(kVector);
  171. EXPECT_EQ(to_string, u"{3,5,7,9}");
  172. }
  173. TEST_F(TypeConversionTest, TestConversion_StringToVector) {
  174. std::u16string from_string = u"{2,3,4,5}";
  175. EXPECT_EQ(
  176. ui::metadata::TypeConverter<std::vector<int>>::FromString(from_string),
  177. std::vector<int>({2, 3, 4, 5}));
  178. }
  179. TEST_F(TypeConversionTest, CheckIsSerializable) {
  180. // Test types with explicitly added converters.
  181. EXPECT_TRUE(ui::metadata::TypeConverter<int8_t>::IsSerializable());
  182. EXPECT_TRUE(ui::metadata::TypeConverter<int16_t>::IsSerializable());
  183. EXPECT_TRUE(ui::metadata::TypeConverter<int32_t>::IsSerializable());
  184. EXPECT_TRUE(ui::metadata::TypeConverter<int64_t>::IsSerializable());
  185. EXPECT_TRUE(ui::metadata::TypeConverter<uint8_t>::IsSerializable());
  186. EXPECT_TRUE(ui::metadata::TypeConverter<uint16_t>::IsSerializable());
  187. EXPECT_TRUE(ui::metadata::TypeConverter<uint32_t>::IsSerializable());
  188. EXPECT_TRUE(ui::metadata::TypeConverter<uint64_t>::IsSerializable());
  189. EXPECT_TRUE(ui::metadata::TypeConverter<float>::IsSerializable());
  190. EXPECT_TRUE(ui::metadata::TypeConverter<double>::IsSerializable());
  191. EXPECT_TRUE(ui::metadata::TypeConverter<bool>::IsSerializable());
  192. EXPECT_TRUE(ui::metadata::TypeConverter<const char*>::IsSerializable());
  193. EXPECT_TRUE(ui::metadata::TypeConverter<std::u16string>::IsSerializable());
  194. EXPECT_TRUE(ui::metadata::TypeConverter<gfx::ShadowValues>::IsSerializable());
  195. EXPECT_TRUE(ui::metadata::TypeConverter<gfx::Size>::IsSerializable());
  196. EXPECT_TRUE(ui::metadata::TypeConverter<gfx::Range>::IsSerializable());
  197. EXPECT_TRUE(ui::metadata::TypeConverter<gfx::Insets>::IsSerializable());
  198. // Test enum type.
  199. EXPECT_TRUE(ui::metadata::TypeConverter<TestResult>::IsSerializable());
  200. // Test aliased types.
  201. EXPECT_TRUE(ui::metadata::TypeConverter<int>::IsSerializable());
  202. EXPECT_TRUE(ui::metadata::TypeConverter<SkColor>::IsSerializable());
  203. // Test absl::optional type.
  204. EXPECT_TRUE(ui::metadata::TypeConverter<
  205. absl::optional<const char*>>::IsSerializable());
  206. EXPECT_TRUE(
  207. ui::metadata::TypeConverter<absl::optional<int>>::IsSerializable());
  208. }