1 // Copyright (c) 2019 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_packets.h"
6
7 #include "absl/memory/memory.h"
8 #include "quiche/quic/platform/api/quic_test.h"
9 #include "quiche/quic/test_tools/quic_test_utils.h"
10 #include "quiche/common/test_tools/quiche_test_utils.h"
11
12 namespace quic {
13 namespace test {
14 namespace {
15
CreateFakePacketHeader()16 QuicPacketHeader CreateFakePacketHeader() {
17 QuicPacketHeader header;
18 header.destination_connection_id = TestConnectionId(1);
19 header.destination_connection_id_included = CONNECTION_ID_PRESENT;
20 header.source_connection_id = TestConnectionId(2);
21 header.source_connection_id_included = CONNECTION_ID_ABSENT;
22 return header;
23 }
24
25 class QuicPacketsTest : public QuicTest {};
26
TEST_F(QuicPacketsTest,GetServerConnectionIdAsRecipient)27 TEST_F(QuicPacketsTest, GetServerConnectionIdAsRecipient) {
28 QuicPacketHeader header = CreateFakePacketHeader();
29 EXPECT_EQ(TestConnectionId(1),
30 GetServerConnectionIdAsRecipient(header, Perspective::IS_SERVER));
31 EXPECT_EQ(TestConnectionId(2),
32 GetServerConnectionIdAsRecipient(header, Perspective::IS_CLIENT));
33 }
34
TEST_F(QuicPacketsTest,GetServerConnectionIdAsSender)35 TEST_F(QuicPacketsTest, GetServerConnectionIdAsSender) {
36 QuicPacketHeader header = CreateFakePacketHeader();
37 EXPECT_EQ(TestConnectionId(2),
38 GetServerConnectionIdAsSender(header, Perspective::IS_SERVER));
39 EXPECT_EQ(TestConnectionId(1),
40 GetServerConnectionIdAsSender(header, Perspective::IS_CLIENT));
41 }
42
TEST_F(QuicPacketsTest,GetServerConnectionIdIncludedAsSender)43 TEST_F(QuicPacketsTest, GetServerConnectionIdIncludedAsSender) {
44 QuicPacketHeader header = CreateFakePacketHeader();
45 EXPECT_EQ(CONNECTION_ID_ABSENT, GetServerConnectionIdIncludedAsSender(
46 header, Perspective::IS_SERVER));
47 EXPECT_EQ(CONNECTION_ID_PRESENT, GetServerConnectionIdIncludedAsSender(
48 header, Perspective::IS_CLIENT));
49 }
50
TEST_F(QuicPacketsTest,GetClientConnectionIdIncludedAsSender)51 TEST_F(QuicPacketsTest, GetClientConnectionIdIncludedAsSender) {
52 QuicPacketHeader header = CreateFakePacketHeader();
53 EXPECT_EQ(CONNECTION_ID_PRESENT, GetClientConnectionIdIncludedAsSender(
54 header, Perspective::IS_SERVER));
55 EXPECT_EQ(CONNECTION_ID_ABSENT, GetClientConnectionIdIncludedAsSender(
56 header, Perspective::IS_CLIENT));
57 }
58
TEST_F(QuicPacketsTest,GetClientConnectionIdAsRecipient)59 TEST_F(QuicPacketsTest, GetClientConnectionIdAsRecipient) {
60 QuicPacketHeader header = CreateFakePacketHeader();
61 EXPECT_EQ(TestConnectionId(2),
62 GetClientConnectionIdAsRecipient(header, Perspective::IS_SERVER));
63 EXPECT_EQ(TestConnectionId(1),
64 GetClientConnectionIdAsRecipient(header, Perspective::IS_CLIENT));
65 }
66
TEST_F(QuicPacketsTest,GetClientConnectionIdAsSender)67 TEST_F(QuicPacketsTest, GetClientConnectionIdAsSender) {
68 QuicPacketHeader header = CreateFakePacketHeader();
69 EXPECT_EQ(TestConnectionId(1),
70 GetClientConnectionIdAsSender(header, Perspective::IS_SERVER));
71 EXPECT_EQ(TestConnectionId(2),
72 GetClientConnectionIdAsSender(header, Perspective::IS_CLIENT));
73 }
74
TEST_F(QuicPacketsTest,CopyQuicPacketHeader)75 TEST_F(QuicPacketsTest, CopyQuicPacketHeader) {
76 QuicPacketHeader header;
77 QuicPacketHeader header2 = CreateFakePacketHeader();
78 EXPECT_NE(header, header2);
79 QuicPacketHeader header3(header2);
80 EXPECT_EQ(header2, header3);
81 }
82
TEST_F(QuicPacketsTest,CopySerializedPacket)83 TEST_F(QuicPacketsTest, CopySerializedPacket) {
84 std::string buffer(1000, 'a');
85 quiche::SimpleBufferAllocator allocator;
86 SerializedPacket packet(QuicPacketNumber(1), PACKET_1BYTE_PACKET_NUMBER,
87 buffer.data(), buffer.length(), /*has_ack=*/false,
88 /*has_stop_waiting=*/false);
89 packet.retransmittable_frames.push_back(QuicFrame(QuicWindowUpdateFrame()));
90 packet.retransmittable_frames.push_back(QuicFrame(QuicStreamFrame()));
91
92 QuicAckFrame ack_frame(InitAckFrame(1));
93 packet.nonretransmittable_frames.push_back(QuicFrame(&ack_frame));
94 packet.nonretransmittable_frames.push_back(QuicFrame(QuicPaddingFrame(-1)));
95
96 std::unique_ptr<SerializedPacket> copy = absl::WrapUnique<SerializedPacket>(
97 CopySerializedPacket(packet, &allocator, /*copy_buffer=*/true));
98 EXPECT_EQ(quic::QuicPacketNumber(1), copy->packet_number);
99 EXPECT_EQ(PACKET_1BYTE_PACKET_NUMBER, copy->packet_number_length);
100 ASSERT_EQ(2u, copy->retransmittable_frames.size());
101 EXPECT_EQ(WINDOW_UPDATE_FRAME, copy->retransmittable_frames[0].type);
102 EXPECT_EQ(STREAM_FRAME, copy->retransmittable_frames[1].type);
103
104 ASSERT_EQ(2u, copy->nonretransmittable_frames.size());
105 EXPECT_EQ(ACK_FRAME, copy->nonretransmittable_frames[0].type);
106 EXPECT_EQ(PADDING_FRAME, copy->nonretransmittable_frames[1].type);
107 EXPECT_EQ(1000u, copy->encrypted_length);
108 quiche::test::CompareCharArraysWithHexError(
109 "encrypted_buffer", copy->encrypted_buffer, copy->encrypted_length,
110 packet.encrypted_buffer, packet.encrypted_length);
111
112 std::unique_ptr<SerializedPacket> copy2 = absl::WrapUnique<SerializedPacket>(
113 CopySerializedPacket(packet, &allocator, /*copy_buffer=*/false));
114 EXPECT_EQ(packet.encrypted_buffer, copy2->encrypted_buffer);
115 EXPECT_EQ(1000u, copy2->encrypted_length);
116 }
117
118 } // namespace
119 } // namespace test
120 } // namespace quic
121