| // Copyright 2024 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "remoting/host/linux/gvariant_ref.h" |
| |
| #include <glib.h> |
| |
| #include <algorithm> |
| #include <array> |
| #include <compare> |
| #include <cstddef> |
| #include <cstdint> |
| #include <iterator> |
| #include <map> |
| #include <optional> |
| #include <set> |
| #include <string> |
| #include <string_view> |
| #include <tuple> |
| #include <utility> |
| #include <variant> |
| #include <vector> |
| |
| #include "base/check.h" |
| #include "base/types/expected.h" |
| #include "remoting/host/linux/gvariant_type.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace remoting::gvariant { |
| namespace { |
| // A type whose mapping provides a From static method. |
| template <typename T, Type C> |
| concept ProvidesFrom = requires(T v) { GVariantRef<C>::template From<T>(v); }; |
| |
| // A type whose mapping provides a TryFrom static method. |
| template <typename T, Type C> |
| concept ProvidesTryFrom = |
| requires(T v) { GVariantRef<C>::template TryFrom<T>(v); }; |
| |
| // A type whose mapping provides an Into static method for the provided Type. |
| template <typename T, Type C> |
| concept ProvidesInto = requires(GVariantRef<C> v) { v.template Into<T>(); }; |
| |
| // A type whose mapping provides a TryInto static method. |
| template <typename T, Type C> |
| concept ProvidesTryInto = |
| requires(GVariantRef<C> v) { v.template TryInto<T>(); }; |
| |
| template <Type Parse, Type Return = Parse> |
| GVariantRef<Return> GVariantParse(const char* text) { |
| GVariant* variant = |
| g_variant_parse(Parse.gvariant_type(), text, nullptr, nullptr, nullptr); |
| CHECK(variant); |
| return GVariantRef<Return>::TakeUnchecked(variant); |
| } |
| |
| } // namespace |
| |
| TEST(GVariantRefTest, EncodesBasicTypes) { |
| EXPECT_EQ(GVariantParse<"b">("true"), GVariantRef<"b">::From(true)); |
| EXPECT_EQ(GVariantParse<"y">("5"), GVariantRef<"y">::From(std::uint8_t{5})); |
| EXPECT_EQ(GVariantParse<"n">("-17"), |
| GVariantRef<"n">::From(std::int16_t{-17})); |
| EXPECT_EQ(GVariantParse<"q">("103"), |
| GVariantRef<"q">::From(std::uint16_t{103})); |
| EXPECT_EQ(GVariantParse<"i">("603"), |
| GVariantRef<"i">::From(std::int32_t{603})); |
| EXPECT_EQ(GVariantParse<"u">("57"), |
| GVariantRef<"u">::From(std::uint32_t{57})); |
| EXPECT_EQ(GVariantParse<"x">("-2037"), |
| GVariantRef<"x">::From(std::int64_t{-2037})); |
| EXPECT_EQ(GVariantParse<"t">("169"), |
| GVariantRef<"t">::From(std::uint64_t{169})); |
| EXPECT_EQ(GVariantParse<"d">("17.5"), GVariantRef<"d">::From(double{17.5})); |
| |
| static_assert(ProvidesFrom<std::int32_t, "i">); |
| static_assert(!ProvidesFrom<std::int32_t, "u">); |
| static_assert(ProvidesFrom<std::int32_t, "*">); |
| static_assert(ProvidesFrom<std::int32_t, "?">); |
| static_assert(!ProvidesTryFrom<std::int32_t, "u">); |
| } |
| |
| TEST(GVariantRefTest, DecodesBasicTypes) { |
| EXPECT_EQ(true, GVariantParse<"b">("true").Into<bool>()); |
| EXPECT_EQ(base::ok(std::uint8_t{124}), |
| (GVariantParse<"y", "*">("124").TryInto<std::uint8_t>())); |
| EXPECT_EQ(std::int16_t{93}, GVariantParse<"n">("93").Into<std::int16_t>()); |
| EXPECT_EQ(base::ok(std::uint16_t{567}), |
| (GVariantParse<"q", "*">("567").TryInto<std::uint16_t>())); |
| EXPECT_EQ(std::int32_t{-91643}, |
| GVariantParse<"i">("-91643").Into<std::int32_t>()); |
| EXPECT_EQ(base::ok(std::uint32_t{7832}), |
| (GVariantParse<"u", "*">("7832").TryInto<std::uint32_t>())); |
| EXPECT_EQ(std::int64_t{9582}, |
| GVariantParse<"x">("9582").Into<std::int64_t>()); |
| EXPECT_EQ(base::ok(std::uint64_t{3245}), |
| (GVariantParse<"t", "*">("3245").TryInto<std::uint64_t>())); |
| EXPECT_EQ(double{72.5}, GVariantParse<"d">("72.5").Into<double>()); |
| |
| EXPECT_FALSE((GVariantParse<"i", "*">("-12").TryInto<double>().has_value())); |
| |
| static_assert(ProvidesInto<std::int32_t, "i">); |
| static_assert(!ProvidesInto<std::int32_t, "u">); |
| static_assert(ProvidesTryInto<std::int32_t, "*">); |
| static_assert(ProvidesTryInto<std::int32_t, "?">); |
| static_assert(!ProvidesTryInto<std::int32_t, "u">); |
| } |
| |
| TEST(GVariantRefTest, Strings) { |
| EXPECT_EQ(base::ok(GVariantParse<"s">("'Hello sailor!'")), |
| GVariantRef<>::TryFrom(std::string("Hello sailor!"))); |
| EXPECT_EQ(GVariantParse<"s">("'Ahoy sailor!'"), |
| GVariantFrom(std::string_view("Ahoy sailor!"))); |
| EXPECT_EQ(GVariantParse<"s">("'So long sailor!'"), |
| GVariantFrom("So long sailor!")); |
| |
| EXPECT_EQ( |
| base::ok(std::string("Welcome back!")), |
| (GVariantParse<"s", "*">("'Welcome back!'").TryInto<std::string>())); |
| EXPECT_EQ(std::string("Welcome back, again!"), |
| GVariantParse<"s">("'Welcome back, again!'").Into<std::string>()); |
| |
| EXPECT_FALSE(GVariantRef<"s">::TryFrom("Invalid\x85string").has_value()); |
| EXPECT_FALSE( |
| (GVariantParse<"i", "*">("-5").TryInto<std::string>().has_value())); |
| |
| static_assert(!ProvidesTryInto<std::string_view, "*">); |
| static_assert(!ProvidesTryInto<char*, "*">); |
| static_assert(!ProvidesTryInto<const char*, "*">); |
| } |
| |
| TEST(GVariantRefTest, Optional) { |
| EXPECT_EQ(GVariantParse<"mi">("just 16"), |
| GVariantRef<"*">::From(std::optional(std::int32_t{16}))); |
| EXPECT_EQ(GVariantParse<"md">("nothing"), |
| GVariantRef<"md">::From(std::optional<double>())); |
| EXPECT_EQ(GVariantParse<"ms">("just 'banana'"), |
| GVariantFrom(std::optional("banana"))); |
| EXPECT_EQ(GVariantParse<"ms">("nothing"), |
| GVariantRef<"ms">::From(std::optional<std::string_view>())); |
| // Indefinite type is okay if the option contains a concrete value. |
| EXPECT_EQ( |
| base::ok(GVariantParse<"mn">("just 539")), |
| GVariantRef<>::TryFrom(std::optional(GVariantFrom(std::int16_t{539})))); |
| |
| EXPECT_EQ( |
| std::optional(std::string("apple")), |
| GVariantParse<"ms">("just 'apple'").Into<std::optional<std::string>>()); |
| EXPECT_EQ( |
| std::optional<std::uint32_t>(), |
| GVariantParse<"mu">("nothing").Into<std::optional<std::uint32_t>>()); |
| EXPECT_EQ(base::ok(std::optional(std::string("peach"))), |
| (GVariantParse<"ms", "*">("just 'peach'") |
| .TryInto<std::optional<std::string>>())); |
| EXPECT_EQ(base::ok(std::optional<std::uint32_t>()), |
| (GVariantParse<"mi", "*">("nothing") |
| .TryInto<std::optional<std::int32_t>>())); |
| |
| EXPECT_FALSE((GVariantParse<"i", "*">("15") |
| .TryInto<std::optional<std::int32_t>>() |
| .has_value())); |
| EXPECT_FALSE((GVariantParse<"mi", "*">("27") |
| .TryInto<std::optional<std::uint8_t>>() |
| .has_value())); |
| // Can't create empty invariant of indefinite type. |
| EXPECT_FALSE( |
| GVariantRef<>::TryFrom(std::optional<GVariantRef<>>()).has_value()); |
| |
| // An indefinite type can't be used with From(), but can be used with other |
| // operations supported by the inner type. |
| static_assert(!ProvidesFrom<std::optional<GVariantRef<>>, "m*"> && |
| ProvidesTryFrom<std::optional<GVariantRef<>>, "m*"> && |
| ProvidesInto<std::optional<GVariantRef<>>, "m*"> && |
| ProvidesTryInto<std::optional<GVariantRef<>>, "m*">); |
| } |
| |
| TEST(GVariantRefTest, Vector) { |
| EXPECT_EQ(GVariantParse<"as">("[]"), |
| GVariantFrom(std::vector<const char*>())); |
| EXPECT_EQ(GVariantParse<"an">("[5, -2, 45, -367, 97, -8]"), |
| GVariantFrom(std::vector<std::int16_t>{5, -2, 45, -367, 97, -8})); |
| |
| EXPECT_EQ(base::ok(std::vector<double>()), |
| (GVariantParse<"ad", "*">("[]").TryInto<std::vector<double>>())); |
| EXPECT_EQ( |
| (std::vector<std::string>{"cabbage", "broccoli", "kale", "cauliflower"}), |
| GVariantParse<"as">("['cabbage', 'broccoli', 'kale', 'cauliflower']") |
| .Into<std::vector<std::string>>()); |
| |
| EXPECT_FALSE((GVariantParse<"i", "*">("7") |
| .TryInto<std::vector<std::int32_t>>() |
| .has_value())); |
| EXPECT_FALSE((GVariantParse<"ai", "*">("[]") |
| .TryInto<std::vector<std::uint8_t>>() |
| .has_value())); |
| |
| // An indefinite type can't be used with From(), but can be used with other |
| // operations supported by the inner type. |
| static_assert(!ProvidesFrom<std::vector<GVariantRef<>>, "a*"> && |
| ProvidesTryFrom<std::vector<GVariantRef<>>, "a*"> && |
| ProvidesInto<std::vector<GVariantRef<>>, "a*"> && |
| ProvidesTryInto<std::vector<GVariantRef<>>, "a*">); |
| } |
| |
| TEST(GVariantRefTest, Map) { |
| EXPECT_EQ(GVariantParse<"a{us}">("{}"), |
| GVariantRef<"*">::From(std::map<std::uint32_t, const char*>())); |
| EXPECT_EQ( |
| GVariantParse<"a{sb}">( |
| "{'a': true, 'b': false, 'c': false, 'd': false, 'e': true}"), |
| GVariantFrom(std::map<std::string_view, bool>{ |
| {"a", true}, {"b", false}, {"c", false}, {"d", false}, {"e", true}})); |
| EXPECT_EQ(GVariantParse<"a{ib}">( |
| "{1: true, 2: false, 3: false, 4: false, 5: true}"), |
| GVariantRef<"a{ib}">::From(std::map<std::int32_t, bool>{ |
| {1, true}, {2, false}, {3, false}, {4, false}, {5, true}})); |
| |
| EXPECT_EQ(base::ok(std::map<bool, std::uint8_t>()), |
| (GVariantParse<"a{by}", "*">("{}") |
| .TryInto<std::map<bool, std::uint8_t>>())); |
| EXPECT_EQ( |
| (std::map<std::int32_t, double>{{1, 1}, {2, 0.5}, {4, 0.25}, {8, 0.125}}), |
| (GVariantParse<"a{id}">("{1: 1, 2: 0.5, 4: 0.25, 8: 0.125}") |
| .Into<std::map<int32_t, double>>())); |
| |
| EXPECT_FALSE((GVariantParse<"i", "*">("-3") |
| .TryInto<std::map<std::uint32_t, std::uint8_t>>() |
| .has_value())); |
| EXPECT_FALSE((GVariantParse<"a{ib}", "*">("{}") |
| .TryInto<std::map<std::uint32_t, std::uint8_t>>() |
| .has_value())); |
| |
| // An indefinite type can't be used with From(), but can be used with other |
| // operations supported by the inner types. |
| using IndefiniteValue = std::map<std::int64_t, GVariantRef<>>; |
| using IndefiniteKey = std::map<GVariantRef<"?">, Boxed<GVariantRef<>>>; |
| static_assert(!ProvidesFrom<IndefiniteValue, "a{x*}"> && |
| ProvidesTryFrom<IndefiniteValue, "a{x*}"> && |
| ProvidesInto<IndefiniteValue, "a{x*}"> && |
| ProvidesTryInto<IndefiniteValue, "a{x*}">); |
| static_assert(!ProvidesFrom<IndefiniteKey, "a{?v}"> && |
| ProvidesTryFrom<IndefiniteKey, "a{?v}"> && |
| ProvidesInto<IndefiniteKey, "a{?v}"> && |
| ProvidesTryInto<IndefiniteKey, "a{?v}">); |
| } |
| |
| TEST(GVariantRefTest, Pair) { |
| EXPECT_EQ(GVariantParse<"{us}">("{31, 'xyzzy'}"), |
| GVariantFrom(std::pair<std::uint32_t, const char*>(31, "xyzzy"))); |
| EXPECT_EQ(GVariantParse<"{xt}">("{-64, 64}"), |
| GVariantRef<"{xt}">::From( |
| std::pair<std::int64_t, std::uint64_t>(-64, 64))); |
| |
| EXPECT_EQ(base::ok(std::pair<bool, std::uint8_t>(true, 9)), |
| (GVariantParse<"{by}", "*">("{true, 9}") |
| .TryInto<std::pair<bool, std::uint8_t>>())); |
| EXPECT_EQ((std::pair<double, std::string>(6.5, "poof")), |
| (GVariantParse<"{ds}">("{6.5, 'poof'}") |
| .Into<std::pair<double, std::string>>())); |
| |
| EXPECT_FALSE((GVariantParse<"{uu}", "*">("{5, 7}") |
| .TryInto<std::pair<std::uint32_t, std::uint8_t>>() |
| .has_value())); |
| } |
| |
| TEST(GVariantRefTest, Range) { |
| EXPECT_EQ(GVariantParse<"ab">("[]"), GVariantFrom(std::array<bool, 0>())); |
| EXPECT_EQ(GVariantParse<"as">("['1', '2', '3', '4', '5']"), |
| GVariantFrom(std::set<std::string>{"5", "4", "3", "2", "1"})); |
| |
| // An indefinite type can't be used with From(), but can be used with |
| // TryFrom(). |
| static_assert(!ProvidesFrom<std::array<GVariantRef<>, 4>, "a*"> && |
| ProvidesTryFrom<std::array<GVariantRef<>, 4>, "a*">); |
| } |
| |
| TEST(GVariantRefTest, Tuple) { |
| EXPECT_EQ(GVariantParse<"()">("()"), GVariantRef<"*">::From(std::tuple())); |
| EXPECT_EQ(GVariantParse<"(ybmds)">("(63, true, 3.0, 'Hello!')"), |
| GVariantFrom(std::tuple(std::uint8_t{63}, true, |
| std::optional(double{3.0}), "Hello!"))); |
| |
| EXPECT_EQ(base::ok(std::tuple()), |
| (GVariantParse<"()", "*">("()").TryInto<std::tuple<>>())); |
| EXPECT_EQ( |
| std::tuple(std::string("fancy"), false, double{-6.75}, std::int64_t{512}), |
| (GVariantParse<"(sbdx)">("('fancy', false, -6.75, 512)") |
| .Into<std::tuple<std::string, bool, double, std::int64_t>>())); |
| |
| EXPECT_FALSE((GVariantParse<"i", "*">("4") |
| .TryInto<std::tuple<std::int32_t>>() |
| .has_value())); |
| EXPECT_FALSE( |
| (GVariantParse<"(sisi)", "*">("('a', 1, 'b', 2)") |
| .TryInto<std::tuple<std::string, std::int32_t, std::string>>() |
| .has_value())); |
| EXPECT_FALSE( |
| (GVariantParse<"(sisi)", "*">("('a', 1, 'b', 2)") |
| .TryInto<std::tuple<std::string, bool, std::string, std::int32_t>>() |
| .has_value())); |
| } |
| |
| TEST(GVariantRefTest, Variant) { |
| using Strings = std::variant<const char*, std::string, std::string_view>; |
| using BasicArrays = |
| std::variant<std::vector<double>, std::vector<std::int32_t>, |
| std::vector<bool>>; |
| using Mixed = std::variant<uint8_t, double, std::optional<std::string_view>, |
| GVariantRef<"?">>; |
| |
| EXPECT_EQ(GVariantParse<"s">("'asparagus'"), |
| GVariantFrom(Strings(std::in_place_index<0>, "asparagus"))); |
| EXPECT_EQ(GVariantParse<"s">("'broccoli'"), |
| GVariantFrom(Strings(std::in_place_index<1>, "broccoli"))); |
| EXPECT_EQ(GVariantParse<"s">("'carrot'"), |
| GVariantFrom(Strings(std::in_place_index<2>, "carrot"))); |
| |
| EXPECT_EQ(GVariantParse<"ad">("[2.0, 3.5]"), |
| GVariantRef<"a?">::From( |
| BasicArrays(std::in_place_index<0>, std::vector{2.0, 3.5}))); |
| EXPECT_EQ(GVariantParse<"ai">("[28, 16]"), |
| GVariantRef<"a?">::From( |
| BasicArrays(std::in_place_index<1>, std::vector{28, 16}))); |
| EXPECT_EQ(GVariantParse<"ab">("[true, false]"), |
| GVariantRef<"a?">::From( |
| BasicArrays(std::in_place_index<2>, std::vector{true, false}))); |
| |
| EXPECT_EQ(GVariantParse<"y">("6"), |
| GVariantFrom(Mixed(std::in_place_index<0>, 6))); |
| EXPECT_EQ(GVariantParse<"d">("8.25"), |
| GVariantFrom(Mixed(std::in_place_index<1>, 8.25))); |
| EXPECT_EQ(GVariantParse<"ms">("just 'delicata squash'"), |
| GVariantFrom(Mixed(std::in_place_index<2>, "delicata squash"))); |
| |
| EXPECT_EQ(Strings(std::in_place_index<1>, "eggplant"), |
| GVariantParse<"s">("'eggplant'").Into<Strings>()); |
| |
| EXPECT_EQ(BasicArrays(std::in_place_index<2>, std::vector{true, false, true}), |
| GVariantParse<"ab">("[true, false, true]").Into<BasicArrays>()); |
| |
| EXPECT_EQ(base::ok(Mixed(std::in_place_index<0>, 12)), |
| (GVariantParse<"y", "*">("12").TryInto<Mixed>())); |
| EXPECT_EQ(Mixed(std::in_place_index<1>, 9.75), |
| GVariantParse<"d">("9.75").Into<GVariantRef<"?">>().Into<Mixed>()); |
| EXPECT_EQ( |
| Mixed(std::in_place_index<3>, GVariantRef<"?">::From(std::int32_t{93})), |
| GVariantParse<"i">("93").Into<Mixed>()); |
| |
| // Doesn't match type string. |
| EXPECT_FALSE((GVariantParse<"i", "*">("16").TryInto<Strings>().has_value())); |
| // Matches indefinite type string, but not any of the variants |
| EXPECT_FALSE( |
| (GVariantParse<"a{sv}", "*">("{}").TryInto<Mixed>().has_value())); |
| // Only matches a variant that doesn't provide TryInto(). |
| EXPECT_FALSE( |
| (GVariantParse<"ms", "*">("just 'fennel'").TryInto<Mixed>().has_value())); |
| |
| static_assert(Mapping<Strings>::kType == Type("s")); |
| static_assert(Mapping<BasicArrays>::kType == Type("a?")); |
| static_assert(Mapping<Mixed>::kType == Type("*")); |
| static_assert(ProvidesTryInto<Strings, "*">); |
| static_assert(ProvidesInto<Strings, "s">); |
| static_assert(!ProvidesTryInto<std::variant<std::string_view>, "*">); |
| static_assert(ProvidesFrom<BasicArrays, "*">); |
| static_assert(!ProvidesFrom<BasicArrays, "ai">); |
| static_assert(ProvidesInto<BasicArrays, "ai">); |
| static_assert(!ProvidesInto<BasicArrays, "*">); |
| } |
| |
| TEST(GVariantRefTest, NestedGVariantRef) { |
| EXPECT_EQ( |
| base::ok(GVariantParse<"(sb)">("('X-387', true)")), |
| GVariantRef<"(s?)">::TryFrom(std::tuple(GVariantRef<"*">::From("X-387"), |
| GVariantRef<"*">::From(true)))); |
| EXPECT_EQ(GVariantParse<"i">("6"), |
| GVariantRef<"?">::From(GVariantRef<"i">::From(std::int32_t{6}))); |
| |
| auto tuple = GVariantParse<"(si)">("('Spiff', 8521)") |
| .Into<std::tuple<GVariantRef<"s">, GVariantRef<>>>(); |
| EXPECT_EQ(std::string("Spiff"), std::get<0>(tuple).Into<std::string>()); |
| EXPECT_EQ(base::ok(std::int32_t{8521}), |
| std::get<1>(tuple).TryInto<std::int32_t>()); |
| EXPECT_EQ(base::ok(true), |
| GVariantRef<"b">::From(true) |
| .Into<GVariantRef<"?">>() |
| .TryInto<GVariantRef<"b">>() |
| .transform([](auto v) { return v.template Into<bool>(); })); |
| |
| EXPECT_FALSE( |
| GVariantRef<"i">::TryFrom(GVariantRef<"?">::From(std::uint8_t{45})) |
| .has_value()); |
| EXPECT_FALSE( |
| GVariantRef<"?">::From(29.5).TryInto<GVariantRef<"u">>().has_value()); |
| |
| static_assert(ProvidesInto<GVariantRef<"a*">, "av">); |
| static_assert(ProvidesFrom<GVariantRef<"av">, "a*">); |
| static_assert(!ProvidesInto<GVariantRef<"av">, "a*">); |
| static_assert(!ProvidesFrom<GVariantRef<"a*">, "av">); |
| static_assert(ProvidesTryInto<GVariantRef<"av">, "a*">); |
| static_assert(ProvidesTryFrom<GVariantRef<"a*">, "av">); |
| static_assert(!ProvidesTryInto<GVariantRef<"av">, "ar">); |
| static_assert(!ProvidesTryFrom<GVariantRef<"ar">, "av">); |
| } |
| |
| TEST(GVariantRefTest, Ignored) { |
| EXPECT_TRUE((GVariantParse<"a{sv}", "*">("{'one': <uint32 1>, 'two': <2.0>}") |
| .TryInto<Ignored>() |
| .has_value())); |
| |
| // Any GVariantRef can be converted to an Ignored, but not the other way |
| // around. |
| static_assert(!ProvidesFrom<Ignored, "*"> && !ProvidesTryFrom<Ignored, "*"> && |
| ProvidesInto<Ignored, "*"> && ProvidesTryInto<Ignored, "*">); |
| } |
| |
| TEST(GVariantRefTest, Boxed) { |
| EXPECT_EQ(GVariantParse<"v">("<'beep'>"), GVariantFrom(Boxed{"beep"})); |
| std::vector<std::string> value = {"chirp", "whistle"}; |
| EXPECT_EQ(GVariantParse<"v">("<['chirp', 'whistle']>"), |
| GVariantFrom(BoxedRef(value))); |
| |
| EXPECT_EQ((Boxed<std::variant<std::uint16_t, std::string>>{"boop"}), |
| (GVariantParse<"v">("<'boop'>") |
| .TryInto<Boxed<std::variant<std::uint16_t, std::string>>>())); |
| EXPECT_EQ(Boxed{GVariantFrom(std::int64_t{-204})}, |
| GVariantParse<"v">("<int64 -204>").Into<Boxed<GVariantRef<>>>()); |
| |
| EXPECT_FALSE((GVariantParse<"i", "*">("-27") |
| .TryInto<Boxed<std::int32_t>>() |
| .has_value())); |
| EXPECT_FALSE((GVariantParse<"v", "*">("<'buzz'>") |
| .TryInto<Boxed<std::int32_t>>() |
| .has_value())); |
| |
| // A boxed value is definite even if the inner type is not. |
| static_assert(ProvidesFrom<std::vector<Boxed<GVariantRef<>>>, "*">); |
| } |
| |
| TEST(GVariantRefTest, FilledMaybe) { |
| EXPECT_EQ(GVariantParse<"ms">("just 'alpaca'"), |
| GVariantFrom(FilledMaybe{"alpaca"})); |
| // Since the value is always guaranteed to be present, indefinite types (whose |
| // actual type is only known at runtime) can be used with From. |
| EXPECT_EQ( |
| GVariantParse<"mx">("-362"), |
| GVariantFrom(FilledMaybe{GVariantRef<"*">::From(std::int64_t{-362})})); |
| std::vector<std::uint16_t> value = {1, 2, 3}; |
| EXPECT_EQ(GVariantParse<"maq">("just [1, 2, 3]"), |
| GVariantFrom(FilledMaybeRef(value))); |
| |
| EXPECT_EQ( |
| base::ok(FilledMaybe{true}), |
| (GVariantParse<"mb", "*">("just true").TryInto<FilledMaybe<bool>>())); |
| |
| EXPECT_FALSE((GVariantParse<"u", "*">("45") |
| .TryInto<FilledMaybe<std::uint32_t>>() |
| .has_value())); |
| EXPECT_FALSE((GVariantParse<"mu", "*">("nothing") |
| .TryInto<FilledMaybe<std::uint32_t>>() |
| .has_value())); |
| EXPECT_FALSE((GVariantParse<"mi", "*">("just 45") |
| .TryInto<FilledMaybe<std::uint32_t>>() |
| .has_value())); |
| } |
| |
| TEST(GVariantRefTest, EmptyArrayOf) { |
| EXPECT_EQ(GVariantParse<"ai">("[]"), |
| GVariantRef<"ai">::From(EmptyArrayOf<"i">())); |
| |
| EXPECT_TRUE(( |
| GVariantParse<"ai", "*">("[]").TryInto<EmptyArrayOf<"i">>().has_value())); |
| |
| EXPECT_FALSE(( |
| GVariantParse<"au", "*">("[]").TryInto<EmptyArrayOf<"i">>().has_value())); |
| EXPECT_FALSE((GVariantParse<"ai", "*">("[7]") |
| .TryInto<EmptyArrayOf<"i">>() |
| .has_value())); |
| } |
| |
| TEST(GVariantRefTest, ObjectPath) { |
| EXPECT_FALSE(ObjectPath::TryFrom("invalid path").has_value()); |
| |
| auto path = ObjectPath::TryFrom("/valid/path"); |
| ASSERT_TRUE(path.has_value()); |
| |
| EXPECT_EQ(GVariantParse<"o">("'/valid/path'"), GVariantFrom(path.value())); |
| EXPECT_EQ(GVariantParse<"o">("'/valid/path'"), |
| GVariantFrom(ObjectPathCStr(path.value()))); |
| |
| EXPECT_EQ(path.value(), |
| GVariantParse<"o">("'/valid/path'").Into<ObjectPath>()); |
| |
| EXPECT_EQ(GVariantParse<"o">("'/path/constant'"), |
| GVariantFrom(ObjectPathCStr("/path/constant"))); |
| |
| EXPECT_FALSE((GVariantParse<"s", "*">("'/valid/path'") |
| .TryInto<ObjectPath>() |
| .has_value())); |
| } |
| |
| TEST(GVariantRefTest, TypeSignature) { |
| EXPECT_FALSE(TypeSignature::TryFrom("invalid signature").has_value()); |
| |
| auto signature = TypeSignature::TryFrom("goodsig"); |
| ASSERT_TRUE(signature.has_value()); |
| |
| EXPECT_EQ(GVariantParse<"g">("'goodsig'"), GVariantFrom(signature.value())); |
| EXPECT_EQ(GVariantParse<"g">("'goodsig'"), |
| GVariantFrom(TypeSignatureCStr(signature.value()))); |
| |
| EXPECT_EQ(signature.value(), |
| GVariantParse<"g">("'goodsig'").Into<TypeSignature>()); |
| |
| EXPECT_EQ(GVariantParse<"g">("'gonstsig'"), |
| GVariantFrom(TypeSignatureCStr("gonstsig"))); |
| |
| EXPECT_FALSE((GVariantParse<"s", "*">("'goodsig'") |
| .TryInto<TypeSignature>() |
| .has_value())); |
| } |
| |
| TEST(GVariantRefTest, FromReferences) { |
| std::int32_t int32 = 57; |
| std::string string = "check"; |
| std::vector<std::uint8_t> data{1, 2, 3, 4, 5}; |
| Boxed<std::vector<std::uint8_t>&> boxed_data{data}; |
| |
| EXPECT_EQ(GVariantParse<"(isv)">("(57, 'check', <[byte 1, 2, 3, 4, 5]>)"), |
| GVariantFrom(std::forward_as_tuple(int32, string, boxed_data))); |
| } |
| |
| TEST(GVariantRefTest, Destructure) { |
| std::int32_t a, b; |
| std::string c; |
| std::int64_t d, f; |
| std::uint64_t e, g; |
| std::uint32_t h; |
| GVariantRef<> i; |
| GVariantParse<"(ii{s((xt)(xt))}uv)">( |
| "(1, 2, {'3', ((4, 5), (6, 7))}, 8, <just byte 9>)") |
| .Destructure( |
| a, b, |
| std::forward_as_tuple( |
| c, std::forward_as_tuple(std::tie(d, e), std::tie(f, g))), |
| h, std::tie(i)); |
| EXPECT_EQ(1, a); |
| EXPECT_EQ(2, b); |
| EXPECT_EQ("3", c); |
| EXPECT_EQ(4, d); |
| EXPECT_EQ(5u, e); |
| EXPECT_EQ(6, f); |
| EXPECT_EQ(7u, g); |
| EXPECT_EQ(8u, h); |
| EXPECT_EQ(GVariantFrom(std::optional<std::uint8_t>(9)), i); |
| } |
| |
| TEST(GVariantRefTest, TryDestructure) { |
| std::int32_t a, b; |
| std::string c; |
| std::int64_t d, f; |
| std::uint64_t e, g; |
| std::uint32_t h; |
| std::uint8_t i; |
| ASSERT_TRUE((GVariantParse<"(ii{sa(xt)}umy)", "*">( |
| "(1, 2, {'3', [(4, 5), (6, 7)]}, 8, just 9)") |
| .TryDestructure(a, b, |
| std::forward_as_tuple( |
| c, std::forward_as_tuple( |
| std::tie(d, e), std::tie(f, g))), |
| h, std::tie(i)) |
| .has_value())); |
| EXPECT_EQ(1, a); |
| EXPECT_EQ(2, b); |
| EXPECT_EQ("3", c); |
| EXPECT_EQ(4, d); |
| EXPECT_EQ(5u, e); |
| EXPECT_EQ(6, f); |
| EXPECT_EQ(7u, g); |
| EXPECT_EQ(8u, h); |
| EXPECT_EQ(9, i); |
| |
| std::int16_t x; |
| EXPECT_FALSE( |
| (GVariantParse<"mn", "*">("nothing").TryDestructure(x).has_value())); |
| |
| std::uint16_t y; |
| std::uint16_t z; |
| EXPECT_FALSE( |
| GVariantParse<"aq">("[1, 2, 3]").TryDestructure(y, z).has_value()); |
| } |
| |
| TEST(GVariantRefTest, Iteration) { |
| auto variant = GVariantParse<"as">("['a', 'b', 'c', 'd', 'e']"); |
| std::vector<std::string> result; |
| for (auto elem : variant) { |
| result.push_back(elem.Into<std::string>()); |
| } |
| EXPECT_EQ((std::vector<std::string>{"a", "b", "c", "d", "e"}), result); |
| |
| std::vector<std::string> rev_result; |
| std::for_each(std::reverse_iterator(variant.end()), |
| std::reverse_iterator(variant.begin()), [&](const auto& elem) { |
| rev_result.push_back(elem.template Into<std::string>()); |
| }); |
| EXPECT_EQ((std::vector<std::string>{"e", "d", "c", "b", "a"}), rev_result); |
| |
| EXPECT_EQ(std::partial_ordering::less, variant.begin() <=> variant.end()); |
| EXPECT_EQ(std::partial_ordering::equivalent, |
| variant.begin() <=> variant.begin()); |
| EXPECT_EQ(5, variant.end() - variant.begin()); |
| EXPECT_EQ("c", (*(variant.begin() + 2)).string_view()); |
| EXPECT_EQ("c", (*(2 + variant.begin())).string_view()); |
| EXPECT_EQ("d", (*(variant.end() - 2)).string_view()); |
| |
| auto inc = variant.begin(); |
| inc += 1; |
| inc += 2; |
| EXPECT_EQ("d", (*inc).string_view()); |
| |
| auto dec = variant.end(); |
| dec -= 1; |
| dec -= 2; |
| EXPECT_EQ("c", (*dec).string_view()); |
| |
| EXPECT_EQ("e", variant.begin()[4].string_view()); |
| } |
| |
| TEST(GVariantRefTest, TupleLike) { |
| auto [a, b, c, d] = GVariantParse<"(iuxt)">("(1, 2, 3, 4)"); |
| |
| EXPECT_EQ(1, a.Into<std::int32_t>()); |
| EXPECT_EQ(2u, b.Into<std::uint32_t>()); |
| EXPECT_EQ(3, c.Into<std::int64_t>()); |
| EXPECT_EQ(4u, d.Into<std::uint64_t>()); |
| } |
| |
| TEST(GVariantRefTest, Lookup) { |
| auto vardict = GVariantParse<"a{sv}">("{'a': <true>, 'b': <int32 5>}"); |
| auto dict2 = GVariantParse<"a{ib}">("{1: false, 3: true, 5: true}"); |
| |
| EXPECT_EQ(GVariantFrom(Boxed{true}), vardict.LookUp("a")); |
| EXPECT_EQ(GVariantFrom(Boxed<std::int32_t>{5}), vardict.LookUp("b")); |
| EXPECT_EQ(std::nullopt, vardict.LookUp("c")); |
| |
| EXPECT_EQ(GVariantFrom(false), dict2.LookUp(std::int32_t{1})); |
| EXPECT_EQ(std::nullopt, dict2.LookUp(std::int32_t{2})); |
| EXPECT_EQ(GVariantFrom(true), dict2.LookUp(std::int32_t{3})); |
| EXPECT_EQ(std::nullopt, dict2.LookUp(std::int32_t{4})); |
| EXPECT_EQ(GVariantFrom(true), dict2.LookUp(std::int32_t{5})); |
| } |
| |
| } // namespace remoting::gvariant |
