1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
// 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 "third_party/blink/renderer/platform/loader/fetch/cached_metadata.h"
#include <variant>
#include "base/containers/span.h"
#include "mojo/public/cpp/base/big_buffer.h"
#include "testing/gmock/include/gmock/gmock-matchers.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace blink {
namespace {
const uint32_t kTestDataTypeId = 123;
const uint64_t kTestTag = 456;
const uint8_t kTestData[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05};
Vector<uint8_t> CreateTestSerializedDataWithMarker(uint32_t marker) {
Vector<uint8_t> serialized_data;
serialized_data.ReserveInitialCapacity(sizeof(CachedMetadataHeader) +
sizeof(kTestData));
serialized_data.AppendSpan(base::byte_span_from_ref(marker));
serialized_data.AppendSpan(base::byte_span_from_ref(kTestDataTypeId));
serialized_data.AppendSpan(base::byte_span_from_ref(kTestTag));
serialized_data.AppendSpan(base::span(kTestData));
return serialized_data;
}
// Creates a test serialized data with the valid marker.
Vector<uint8_t> CreateTestSerializedData() {
return CreateTestSerializedDataWithMarker(
CachedMetadataHandler::kSingleEntryWithTag);
}
void CheckTestCachedMetadata(scoped_refptr<CachedMetadata> cached_metadata) {
ASSERT_TRUE(cached_metadata);
EXPECT_EQ(cached_metadata->DataTypeID(), kTestDataTypeId);
EXPECT_THAT(cached_metadata->SerializedData(),
testing::ElementsAreArray(CreateTestSerializedData()));
EXPECT_THAT(cached_metadata->Data(), testing::ElementsAreArray(kTestData));
EXPECT_EQ(cached_metadata->tag(), kTestTag);
auto drained_data = std::move(*cached_metadata).DrainSerializedData();
if (std::holds_alternative<Vector<uint8_t>>(drained_data)) {
EXPECT_THAT(std::get<Vector<uint8_t>>(drained_data),
testing::ElementsAreArray(CreateTestSerializedData()));
return;
}
CHECK(std::holds_alternative<mojo_base::BigBuffer>(drained_data));
mojo_base::BigBuffer drained_big_buffer =
std::move(std::get<mojo_base::BigBuffer>(drained_data));
EXPECT_THAT(base::span(drained_big_buffer),
testing::ElementsAreArray(CreateTestSerializedData()));
}
TEST(CachedMetadataTest, GetSerializedDataHeader) {
Vector<uint8_t> header_vector = CachedMetadata::GetSerializedDataHeader(
kTestDataTypeId, /*estimated_body_size=*/10, kTestTag);
EXPECT_EQ(header_vector.size(), sizeof(CachedMetadataHeader));
const CachedMetadataHeader* header =
reinterpret_cast<const CachedMetadataHeader*>(header_vector.data());
EXPECT_EQ(header->marker, CachedMetadataHandler::kSingleEntryWithTag);
EXPECT_EQ(header->type, kTestDataTypeId);
EXPECT_EQ(header->tag, kTestTag);
}
TEST(CachedMetadataTest, CreateFromBufferWithDataTypeIdAndTag) {
CheckTestCachedMetadata(
CachedMetadata::Create(kTestDataTypeId, base::span(kTestData), kTestTag));
}
TEST(CachedMetadataTest, CreateFromSerializedDataVector) {
Vector<uint8_t> data = CreateTestSerializedData();
CheckTestCachedMetadata(CachedMetadata::CreateFromSerializedData(data));
}
TEST(CachedMetadataTest, CreateFromSerializedDataBigBuffer) {
Vector<uint8_t> data = CreateTestSerializedData();
mojo_base::BigBuffer big_buffer(data);
CheckTestCachedMetadata(CachedMetadata::CreateFromSerializedData(big_buffer));
// `big_buffer` must be moved into the created CachedMetadata.
EXPECT_EQ(big_buffer.size(), 0u);
}
TEST(CachedMetadataTest, CreateFromSerializedDataTooSmall) {
Vector<uint8_t> data = Vector<uint8_t>(sizeof(CachedMetadataHeader));
EXPECT_FALSE(CachedMetadata::CreateFromSerializedData(data));
mojo_base::BigBuffer big_buffer(data);
EXPECT_FALSE(CachedMetadata::CreateFromSerializedData(big_buffer));
// `big_buffer` must not be moved into the created CachedMetadata.
EXPECT_EQ(big_buffer.size(), data.size());
}
TEST(CachedMetadataTest, CreateFromSerializedDataWithInvalidMarker) {
// Creates a test serialized data with an invalid marker.
Vector<uint8_t> data = CreateTestSerializedDataWithMarker(
CachedMetadataHandler::kSingleEntryWithTag + 1);
EXPECT_FALSE(CachedMetadata::CreateFromSerializedData(data));
mojo_base::BigBuffer big_buffer(data);
EXPECT_FALSE(CachedMetadata::CreateFromSerializedData(big_buffer));
// `big_buffer` must not be moved into the created CachedMetadata.
EXPECT_EQ(big_buffer.size(), data.size());
}
} // namespace
} // namespace blink
|
