1 // Copyright (c) 2018 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/qpack/qpack_decoder_stream_receiver.h"
6
7 #include "absl/strings/escaping.h"
8 #include "absl/strings/string_view.h"
9 #include "quiche/quic/platform/api/quic_test.h"
10
11 using testing::Eq;
12 using testing::StrictMock;
13
14 namespace quic {
15 namespace test {
16 namespace {
17
18 class MockDelegate : public QpackDecoderStreamReceiver::Delegate {
19 public:
20 ~MockDelegate() override = default;
21
22 MOCK_METHOD(void, OnInsertCountIncrement, (uint64_t increment), (override));
23 MOCK_METHOD(void, OnHeaderAcknowledgement, (QuicStreamId stream_id),
24 (override));
25 MOCK_METHOD(void, OnStreamCancellation, (QuicStreamId stream_id), (override));
26 MOCK_METHOD(void, OnErrorDetected,
27 (QuicErrorCode error_code, absl::string_view error_message),
28 (override));
29 };
30
31 class QpackDecoderStreamReceiverTest : public QuicTest {
32 protected:
QpackDecoderStreamReceiverTest()33 QpackDecoderStreamReceiverTest() : stream_(&delegate_) {}
34 ~QpackDecoderStreamReceiverTest() override = default;
35
36 QpackDecoderStreamReceiver stream_;
37 StrictMock<MockDelegate> delegate_;
38 };
39
TEST_F(QpackDecoderStreamReceiverTest,InsertCountIncrement)40 TEST_F(QpackDecoderStreamReceiverTest, InsertCountIncrement) {
41 std::string encoded_data;
42 EXPECT_CALL(delegate_, OnInsertCountIncrement(0));
43 ASSERT_TRUE(absl::HexStringToBytes("00", &encoded_data));
44 stream_.Decode(encoded_data);
45
46 EXPECT_CALL(delegate_, OnInsertCountIncrement(10));
47 ASSERT_TRUE(absl::HexStringToBytes("0a", &encoded_data));
48 stream_.Decode(encoded_data);
49
50 EXPECT_CALL(delegate_, OnInsertCountIncrement(63));
51 ASSERT_TRUE(absl::HexStringToBytes("3f00", &encoded_data));
52 stream_.Decode(encoded_data);
53
54 EXPECT_CALL(delegate_, OnInsertCountIncrement(200));
55 ASSERT_TRUE(absl::HexStringToBytes("3f8901", &encoded_data));
56 stream_.Decode(encoded_data);
57
58 EXPECT_CALL(delegate_,
59 OnErrorDetected(QUIC_QPACK_DECODER_STREAM_INTEGER_TOO_LARGE,
60 Eq("Encoded integer too large.")));
61 ASSERT_TRUE(absl::HexStringToBytes("3fffffffffffffffffffff", &encoded_data));
62 stream_.Decode(encoded_data);
63 }
64
TEST_F(QpackDecoderStreamReceiverTest,HeaderAcknowledgement)65 TEST_F(QpackDecoderStreamReceiverTest, HeaderAcknowledgement) {
66 std::string encoded_data;
67 EXPECT_CALL(delegate_, OnHeaderAcknowledgement(0));
68 ASSERT_TRUE(absl::HexStringToBytes("80", &encoded_data));
69 stream_.Decode(encoded_data);
70
71 EXPECT_CALL(delegate_, OnHeaderAcknowledgement(37));
72 ASSERT_TRUE(absl::HexStringToBytes("a5", &encoded_data));
73 stream_.Decode(encoded_data);
74
75 EXPECT_CALL(delegate_, OnHeaderAcknowledgement(127));
76 ASSERT_TRUE(absl::HexStringToBytes("ff00", &encoded_data));
77 stream_.Decode(encoded_data);
78
79 EXPECT_CALL(delegate_, OnHeaderAcknowledgement(503));
80 ASSERT_TRUE(absl::HexStringToBytes("fff802", &encoded_data));
81 stream_.Decode(encoded_data);
82
83 EXPECT_CALL(delegate_,
84 OnErrorDetected(QUIC_QPACK_DECODER_STREAM_INTEGER_TOO_LARGE,
85 Eq("Encoded integer too large.")));
86 ASSERT_TRUE(absl::HexStringToBytes("ffffffffffffffffffffff", &encoded_data));
87 stream_.Decode(encoded_data);
88 }
89
TEST_F(QpackDecoderStreamReceiverTest,StreamCancellation)90 TEST_F(QpackDecoderStreamReceiverTest, StreamCancellation) {
91 std::string encoded_data;
92 EXPECT_CALL(delegate_, OnStreamCancellation(0));
93 ASSERT_TRUE(absl::HexStringToBytes("40", &encoded_data));
94 stream_.Decode(encoded_data);
95
96 EXPECT_CALL(delegate_, OnStreamCancellation(19));
97 ASSERT_TRUE(absl::HexStringToBytes("53", &encoded_data));
98 stream_.Decode(encoded_data);
99
100 EXPECT_CALL(delegate_, OnStreamCancellation(63));
101 ASSERT_TRUE(absl::HexStringToBytes("7f00", &encoded_data));
102 stream_.Decode(encoded_data);
103
104 EXPECT_CALL(delegate_, OnStreamCancellation(110));
105 ASSERT_TRUE(absl::HexStringToBytes("7f2f", &encoded_data));
106 stream_.Decode(encoded_data);
107
108 EXPECT_CALL(delegate_,
109 OnErrorDetected(QUIC_QPACK_DECODER_STREAM_INTEGER_TOO_LARGE,
110 Eq("Encoded integer too large.")));
111 ASSERT_TRUE(absl::HexStringToBytes("7fffffffffffffffffffff", &encoded_data));
112 stream_.Decode(encoded_data);
113 }
114
115 } // namespace
116 } // namespace test
117 } // namespace quic
118