ikan Uploader :
Directory : /home/ubuntu/node-v16.18.1/deps/v8/third_party/inspector_protocol/crdtp/
Upload File : |
| Current File : //home/ubuntu/node-v16.18.1/deps/v8/third_party/inspector_protocol/crdtp/serializer_traits_test.cc |
// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "serializer_traits.h"
#include <array>
#include "serializable.h"
#include "test_platform.h"
// The purpose of this test is to ensure that the
// {Field}SerializerTraits<X>::Serialize methods invoke the appropriate
// functions from cbor.h; so, it's usually sufficient to compare with what
// cbor.h function invocations would produce, rather than making assertions on
// the specific bytes emitted by the SerializerTraits code.
namespace v8_crdtp {
namespace {
// =============================================================================
// SerializerTraits - Encodes field values of protocol objects in CBOR.
// =============================================================================
TEST(SerializerTraits, Bool) {
std::vector<uint8_t> out;
SerializerTraits<bool>::Serialize(true, &out);
SerializerTraits<bool>::Serialize(false, &out);
EXPECT_THAT(out,
testing::ElementsAre(cbor::EncodeTrue(), cbor::EncodeFalse()));
}
TEST(SerializerTraits, Double) {
std::vector<uint8_t> out;
SerializerTraits<double>::Serialize(1.00001, &out);
std::vector<uint8_t> expected;
cbor::EncodeDouble(1.00001, &expected);
EXPECT_THAT(out, testing::ElementsAreArray(expected));
}
TEST(SerializerTraits, Int32) {
std::vector<uint8_t> out;
SerializerTraits<int32_t>::Serialize(42, &out);
std::vector<uint8_t> expected;
cbor::EncodeInt32(42, &expected);
EXPECT_THAT(out, testing::ElementsAreArray(expected));
}
TEST(SerializerTraits, VectorOfInt32) {
std::vector<int32_t> ints = {1, 2, 3};
std::vector<uint8_t> out;
SerializerTraits<std::vector<int32_t>>::Serialize(ints, &out);
std::vector<uint8_t> expected;
expected.push_back(cbor::EncodeIndefiniteLengthArrayStart());
for (int32_t v : ints)
cbor::EncodeInt32(v, &expected);
expected.push_back(cbor::EncodeStop());
EXPECT_THAT(out, testing::ElementsAreArray(expected));
}
// Foo is an example for a domain specific type.
class Foo : public Serializable {
public:
Foo(int32_t value) : value(value) {}
int32_t value;
void AppendSerialized(std::vector<uint8_t>* out) const override {
// In production, this would be generated code which emits a
// CBOR map that has STRING8 keys corresponding to the field names
// and field values encoded using SerializerTraits::Serialize.
//
// For the test we simplify this drastically and just emit the field
// value, for conveniently testing std::vector<std::unique_ptr<Foo>>,
// as well as the convenience methods for raw pointer and unique_ptr.
SerializerTraits<int32_t>::Serialize(value, out);
}
};
TEST(SerializerTraits, VectorOfDomainSpecificType) {
std::vector<std::unique_ptr<Foo>> foos;
foos.push_back(std::make_unique<Foo>(1));
foos.push_back(std::make_unique<Foo>(2));
foos.push_back(std::make_unique<Foo>(3));
std::vector<uint8_t> out;
SerializerTraits<std::vector<std::unique_ptr<Foo>>>::Serialize(foos, &out);
std::vector<uint8_t> expected;
expected.push_back(cbor::EncodeIndefiniteLengthArrayStart());
for (int32_t v : {1, 2, 3})
cbor::EncodeInt32(v, &expected);
expected.push_back(cbor::EncodeStop());
EXPECT_THAT(out, testing::ElementsAreArray(expected));
}
TEST(SerializerTraits, ConstRefAndUniquePtr) {
// Shows that SerializerTraits<Foo> allows unique_ptr.
Foo foo(42);
auto bar = std::make_unique<Foo>(21);
std::vector<uint8_t> out;
// In this case, |foo| is taken as a const Foo&.
SerializerTraits<Foo>::Serialize(foo, &out);
// In this case, |bar| is taken as a const std::unique_ptr<Foo>&.
SerializerTraits<std::unique_ptr<Foo>>::Serialize(bar, &out);
std::vector<uint8_t> expected;
cbor::EncodeInt32(42, &expected);
cbor::EncodeInt32(21, &expected);
EXPECT_THAT(out, testing::ElementsAreArray(expected));
}
TEST(SerializerTraits, UTF8String) {
std::string msg = "Hello, 🌎.";
std::vector<uint8_t> out;
SerializerTraits<std::string>::Serialize(msg, &out);
std::vector<uint8_t> expected;
cbor::EncodeString8(SpanFrom(msg), &expected);
EXPECT_THAT(out, testing::ElementsAreArray(expected));
}
// A trivial model of Exported.
// (see
// https://cs.chromium.org/chromium/src/out/Debug/gen/v8/include/inspector/Debugger.h).
struct Exported {
std::string msg;
void AppendSerialized(std::vector<uint8_t>* out) const {
cbor::EncodeString8(SpanFrom(msg), out);
}
};
TEST(SerializerTraits, Exported) {
Exported exported;
exported.msg = "Hello, world.";
std::vector<uint8_t> out;
SerializerTraits<Exported>::Serialize(exported, &out);
std::vector<uint8_t> expected;
cbor::EncodeString8(SpanFrom(exported.msg), &expected);
EXPECT_THAT(out, testing::ElementsAreArray(expected));
}
// =============================================================================
// FieldSerializerTraits - Encodes fields of protocol objects in CBOR
// =============================================================================
TEST(FieldSerializerTraits, RequiredField) {
std::string value = "Hello, world.";
std::vector<uint8_t> out;
SerializeField(SpanFrom("msg"), value, &out);
std::vector<uint8_t> expected;
cbor::EncodeString8(SpanFrom("msg"), &expected);
cbor::EncodeString8(SpanFrom(value), &expected);
EXPECT_THAT(out, testing::ElementsAreArray(expected));
}
template <typename T>
class FieldSerializerTraits_MaybeTest : public ::testing::Test {};
using MaybeTypes =
::testing::Types<detail::ValueMaybe<bool>,
detail::ValueMaybe<double>,
detail::ValueMaybe<int32_t>,
detail::ValueMaybe<std::string>,
detail::PtrMaybe<Foo>,
detail::PtrMaybe<std::vector<std::unique_ptr<Foo>>>>;
TYPED_TEST_SUITE(FieldSerializerTraits_MaybeTest, MaybeTypes);
TYPED_TEST(FieldSerializerTraits_MaybeTest, NoOutputForFieldsIfNotJust) {
std::vector<uint8_t> out;
SerializeField(SpanFrom("maybe"), TypeParam(), &out);
EXPECT_THAT(out, testing::ElementsAreArray(std::vector<uint8_t>()));
}
TEST(FieldSerializerTraits, MaybeBool) {
std::vector<uint8_t> out;
SerializeField(SpanFrom("true"), detail::ValueMaybe<bool>(true), &out);
SerializeField(SpanFrom("false"), detail::ValueMaybe<bool>(false), &out);
std::vector<uint8_t> expected;
cbor::EncodeString8(SpanFrom("true"), &expected);
expected.push_back(cbor::EncodeTrue());
cbor::EncodeString8(SpanFrom("false"), &expected);
expected.push_back(cbor::EncodeFalse());
EXPECT_THAT(out, testing::ElementsAreArray(expected));
}
TEST(FieldSerializerTraits, MaybeDouble) {
std::vector<uint8_t> out;
SerializeField(SpanFrom("dbl"), detail::ValueMaybe<double>(3.14), &out);
std::vector<uint8_t> expected;
cbor::EncodeString8(SpanFrom("dbl"), &expected);
cbor::EncodeDouble(3.14, &expected);
EXPECT_THAT(out, testing::ElementsAreArray(expected));
}
TEST(FieldSerializerTraits, MaybePtrFoo) {
std::vector<uint8_t> out;
SerializeField(SpanFrom("foo"),
detail::PtrMaybe<Foo>(std::make_unique<Foo>(42)), &out);
std::vector<uint8_t> expected;
cbor::EncodeString8(SpanFrom("foo"), &expected);
cbor::EncodeInt32(42, &expected); // Simplified relative to production.
EXPECT_THAT(out, testing::ElementsAreArray(expected));
}
} // namespace
} // namespace v8_crdtp
Kontol Shell Bypass