1 // Copyright 2022 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
5 #include "quiche/quic/core/quic_stream_priority.h"
6
7 #include "quiche/quic/core/quic_types.h"
8 #include "quiche/common/platform/api/quiche_test.h"
9
10 namespace quic::test {
11
TEST(HttpStreamPriority,DefaultConstructed)12 TEST(HttpStreamPriority, DefaultConstructed) {
13 HttpStreamPriority priority;
14
15 EXPECT_EQ(HttpStreamPriority::kDefaultUrgency, priority.urgency);
16 EXPECT_EQ(HttpStreamPriority::kDefaultIncremental, priority.incremental);
17 }
18
TEST(HttpStreamPriority,Equals)19 TEST(HttpStreamPriority, Equals) {
20 EXPECT_EQ((HttpStreamPriority()),
21 (HttpStreamPriority{HttpStreamPriority::kDefaultUrgency,
22 HttpStreamPriority::kDefaultIncremental}));
23 EXPECT_EQ((HttpStreamPriority{5, true}), (HttpStreamPriority{5, true}));
24 EXPECT_EQ((HttpStreamPriority{2, false}), (HttpStreamPriority{2, false}));
25 EXPECT_EQ((HttpStreamPriority{11, true}), (HttpStreamPriority{11, true}));
26
27 EXPECT_NE((HttpStreamPriority{1, true}), (HttpStreamPriority{3, true}));
28 EXPECT_NE((HttpStreamPriority{4, false}), (HttpStreamPriority{4, true}));
29 EXPECT_NE((HttpStreamPriority{6, true}), (HttpStreamPriority{2, false}));
30 EXPECT_NE((HttpStreamPriority{12, true}), (HttpStreamPriority{9, true}));
31 EXPECT_NE((HttpStreamPriority{2, false}), (HttpStreamPriority{8, false}));
32 }
33
TEST(WebTransportStreamPriority,DefaultConstructed)34 TEST(WebTransportStreamPriority, DefaultConstructed) {
35 WebTransportStreamPriority priority;
36
37 EXPECT_EQ(priority.stream_type,
38 WebTransportStreamPriority::StreamType::kData);
39 EXPECT_EQ(priority.send_order, 0);
40 }
41
TEST(WebTransportStreamPriority,Equals)42 TEST(WebTransportStreamPriority, Equals) {
43 EXPECT_EQ(WebTransportStreamPriority(),
44 (WebTransportStreamPriority{
45 WebTransportStreamPriority::StreamType::kData, 0}));
46 EXPECT_NE(WebTransportStreamPriority(),
47 (WebTransportStreamPriority{
48 WebTransportStreamPriority::StreamType::kData, 1}));
49 EXPECT_NE(WebTransportStreamPriority(),
50 (WebTransportStreamPriority{
51 WebTransportStreamPriority::StreamType::kHttp, 0}));
52 }
53
TEST(QuicStreamPriority,Default)54 TEST(QuicStreamPriority, Default) {
55 EXPECT_EQ(QuicStreamPriority::Default(QuicPriorityType::kHttp).http(),
56 HttpStreamPriority());
57 EXPECT_EQ(QuicStreamPriority::Default(QuicPriorityType::kWebTransport)
58 .web_transport(),
59 WebTransportStreamPriority());
60 }
61
TEST(QuicStreamPriority,Equals)62 TEST(QuicStreamPriority, Equals) {
63 EXPECT_EQ(QuicStreamPriority::Default(QuicPriorityType::kHttp),
64 QuicStreamPriority(HttpStreamPriority()));
65 EXPECT_EQ(QuicStreamPriority::Default(QuicPriorityType::kWebTransport),
66 QuicStreamPriority(WebTransportStreamPriority()));
67 }
68
TEST(QuicStreamPriority,Type)69 TEST(QuicStreamPriority, Type) {
70 EXPECT_EQ(QuicStreamPriority(HttpStreamPriority()).type(),
71 QuicPriorityType::kHttp);
72 EXPECT_EQ(QuicStreamPriority(WebTransportStreamPriority()).type(),
73 QuicPriorityType::kWebTransport);
74 }
75
TEST(SerializePriorityFieldValueTest,SerializePriorityFieldValue)76 TEST(SerializePriorityFieldValueTest, SerializePriorityFieldValue) {
77 // Default value is omitted.
78 EXPECT_EQ("", SerializePriorityFieldValue(
79 {/* urgency = */ 3, /* incremental = */ false}));
80 EXPECT_EQ("u=5", SerializePriorityFieldValue(
81 {/* urgency = */ 5, /* incremental = */ false}));
82 EXPECT_EQ("i", SerializePriorityFieldValue(
83 {/* urgency = */ 3, /* incremental = */ true}));
84 EXPECT_EQ("u=0, i", SerializePriorityFieldValue(
85 {/* urgency = */ 0, /* incremental = */ true}));
86 // Out-of-bound value is ignored.
87 EXPECT_EQ("i", SerializePriorityFieldValue(
88 {/* urgency = */ 9, /* incremental = */ true}));
89 }
90
TEST(ParsePriorityFieldValueTest,ParsePriorityFieldValue)91 TEST(ParsePriorityFieldValueTest, ParsePriorityFieldValue) {
92 // Default values
93 std::optional<HttpStreamPriority> result = ParsePriorityFieldValue("");
94 ASSERT_TRUE(result.has_value());
95 EXPECT_EQ(3, result->urgency);
96 EXPECT_FALSE(result->incremental);
97
98 result = ParsePriorityFieldValue("i=?1");
99 ASSERT_TRUE(result.has_value());
100 EXPECT_EQ(3, result->urgency);
101 EXPECT_TRUE(result->incremental);
102
103 result = ParsePriorityFieldValue("u=5");
104 ASSERT_TRUE(result.has_value());
105 EXPECT_EQ(5, result->urgency);
106 EXPECT_FALSE(result->incremental);
107
108 result = ParsePriorityFieldValue("u=5, i");
109 ASSERT_TRUE(result.has_value());
110 EXPECT_EQ(5, result->urgency);
111 EXPECT_TRUE(result->incremental);
112
113 result = ParsePriorityFieldValue("i, u=1");
114 ASSERT_TRUE(result.has_value());
115 EXPECT_EQ(1, result->urgency);
116 EXPECT_TRUE(result->incremental);
117
118 // Duplicate values are allowed.
119 result = ParsePriorityFieldValue("u=5, i=?1, i=?0, u=2");
120 ASSERT_TRUE(result.has_value());
121 EXPECT_EQ(2, result->urgency);
122 EXPECT_FALSE(result->incremental);
123
124 // Unknown parameters MUST be ignored.
125 result = ParsePriorityFieldValue("a=42, u=4, i=?0");
126 ASSERT_TRUE(result.has_value());
127 EXPECT_EQ(4, result->urgency);
128 EXPECT_FALSE(result->incremental);
129
130 // Out-of-range values MUST be ignored.
131 result = ParsePriorityFieldValue("u=-2, i");
132 ASSERT_TRUE(result.has_value());
133 EXPECT_EQ(3, result->urgency);
134 EXPECT_TRUE(result->incremental);
135
136 // Values of unexpected types MUST be ignored.
137 result = ParsePriorityFieldValue("u=4.2, i=\"foo\"");
138 ASSERT_TRUE(result.has_value());
139 EXPECT_EQ(3, result->urgency);
140 EXPECT_FALSE(result->incremental);
141
142 // Values of the right type but different names are ignored.
143 result = ParsePriorityFieldValue("a=4, b=?1");
144 ASSERT_TRUE(result.has_value());
145 EXPECT_EQ(3, result->urgency);
146 EXPECT_FALSE(result->incremental);
147
148 // Cannot be parsed as structured headers.
149 result = ParsePriorityFieldValue("000");
150 EXPECT_FALSE(result.has_value());
151
152 // Inner list dictionary values are ignored.
153 result = ParsePriorityFieldValue("a=(1 2), u=1");
154 ASSERT_TRUE(result.has_value());
155 EXPECT_EQ(1, result->urgency);
156 EXPECT_FALSE(result->incremental);
157 }
158
159 } // namespace quic::test
160