diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 17:32:43 +0000 |
commit | 6bf0a5cb5034a7e684dcc3500e841785237ce2dd (patch) | |
tree | a68f146d7fa01f0134297619fbe7e33db084e0aa /third_party/libwebrtc/pc/sctp_utils_unittest.cc | |
parent | Initial commit. (diff) | |
download | thunderbird-upstream.tar.xz thunderbird-upstream.zip |
Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'third_party/libwebrtc/pc/sctp_utils_unittest.cc')
-rw-r--r-- | third_party/libwebrtc/pc/sctp_utils_unittest.cc | 196 |
1 files changed, 196 insertions, 0 deletions
diff --git a/third_party/libwebrtc/pc/sctp_utils_unittest.cc b/third_party/libwebrtc/pc/sctp_utils_unittest.cc new file mode 100644 index 0000000000..146886b8cb --- /dev/null +++ b/third_party/libwebrtc/pc/sctp_utils_unittest.cc @@ -0,0 +1,196 @@ +/* + * Copyright 2013 The WebRTC project authors. All Rights Reserved. + * + * Use of this source code is governed by a BSD-style license + * that can be found in the LICENSE file in the root of the source + * tree. An additional intellectual property rights grant can be found + * in the file PATENTS. All contributing project authors may + * be found in the AUTHORS file in the root of the source tree. + */ + +#include "pc/sctp_utils.h" + +#include <stdint.h> + +#include "absl/types/optional.h" +#include "api/priority.h" +#include "rtc_base/byte_buffer.h" +#include "rtc_base/copy_on_write_buffer.h" +#include "test/gtest.h" + +class SctpUtilsTest : public ::testing::Test { + public: + void VerifyOpenMessageFormat(const rtc::CopyOnWriteBuffer& packet, + const std::string& label, + const webrtc::DataChannelInit& config) { + uint8_t message_type; + uint8_t channel_type; + uint32_t reliability; + uint16_t priority; + uint16_t label_length; + uint16_t protocol_length; + + rtc::ByteBufferReader buffer(packet.data<char>(), packet.size()); + ASSERT_TRUE(buffer.ReadUInt8(&message_type)); + EXPECT_EQ(0x03, message_type); + + ASSERT_TRUE(buffer.ReadUInt8(&channel_type)); + if (config.ordered) { + EXPECT_EQ( + config.maxRetransmits ? 0x01 : (config.maxRetransmitTime ? 0x02 : 0), + channel_type); + } else { + EXPECT_EQ(config.maxRetransmits + ? 0x81 + : (config.maxRetransmitTime ? 0x82 : 0x80), + channel_type); + } + + ASSERT_TRUE(buffer.ReadUInt16(&priority)); + if (config.priority) { + // Exact values are checked by round-trip conversion, but + // all values defined are greater than zero. + EXPECT_GT(priority, 0); + } else { + EXPECT_EQ(priority, 0); + } + + ASSERT_TRUE(buffer.ReadUInt32(&reliability)); + if (config.maxRetransmits || config.maxRetransmitTime) { + EXPECT_EQ(config.maxRetransmits ? *config.maxRetransmits + : *config.maxRetransmitTime, + static_cast<int>(reliability)); + } + + ASSERT_TRUE(buffer.ReadUInt16(&label_length)); + ASSERT_TRUE(buffer.ReadUInt16(&protocol_length)); + EXPECT_EQ(label.size(), label_length); + EXPECT_EQ(config.protocol.size(), protocol_length); + + std::string label_output; + ASSERT_TRUE(buffer.ReadString(&label_output, label_length)); + EXPECT_EQ(label, label_output); + std::string protocol_output; + ASSERT_TRUE(buffer.ReadString(&protocol_output, protocol_length)); + EXPECT_EQ(config.protocol, protocol_output); + } +}; + +TEST_F(SctpUtilsTest, WriteParseOpenMessageWithOrderedReliable) { + webrtc::DataChannelInit config; + std::string label = "abc"; + config.protocol = "y"; + + rtc::CopyOnWriteBuffer packet; + ASSERT_TRUE(webrtc::WriteDataChannelOpenMessage(label, config, &packet)); + + VerifyOpenMessageFormat(packet, label, config); + + std::string output_label; + webrtc::DataChannelInit output_config; + ASSERT_TRUE(webrtc::ParseDataChannelOpenMessage(packet, &output_label, + &output_config)); + + EXPECT_EQ(label, output_label); + EXPECT_EQ(config.protocol, output_config.protocol); + EXPECT_EQ(config.ordered, output_config.ordered); + EXPECT_EQ(config.maxRetransmitTime, output_config.maxRetransmitTime); + EXPECT_EQ(config.maxRetransmits, output_config.maxRetransmits); +} + +TEST_F(SctpUtilsTest, WriteParseOpenMessageWithMaxRetransmitTime) { + webrtc::DataChannelInit config; + std::string label = "abc"; + config.ordered = false; + config.maxRetransmitTime = 10; + config.protocol = "y"; + + rtc::CopyOnWriteBuffer packet; + ASSERT_TRUE(webrtc::WriteDataChannelOpenMessage(label, config, &packet)); + + VerifyOpenMessageFormat(packet, label, config); + + std::string output_label; + webrtc::DataChannelInit output_config; + ASSERT_TRUE(webrtc::ParseDataChannelOpenMessage(packet, &output_label, + &output_config)); + + EXPECT_EQ(label, output_label); + EXPECT_EQ(config.protocol, output_config.protocol); + EXPECT_EQ(config.ordered, output_config.ordered); + EXPECT_EQ(*config.maxRetransmitTime, *output_config.maxRetransmitTime); + EXPECT_FALSE(output_config.maxRetransmits); +} + +TEST_F(SctpUtilsTest, WriteParseOpenMessageWithMaxRetransmits) { + webrtc::DataChannelInit config; + std::string label = "abc"; + config.maxRetransmits = 10; + config.protocol = "y"; + + rtc::CopyOnWriteBuffer packet; + ASSERT_TRUE(webrtc::WriteDataChannelOpenMessage(label, config, &packet)); + + VerifyOpenMessageFormat(packet, label, config); + + std::string output_label; + webrtc::DataChannelInit output_config; + ASSERT_TRUE(webrtc::ParseDataChannelOpenMessage(packet, &output_label, + &output_config)); + + EXPECT_EQ(label, output_label); + EXPECT_EQ(config.protocol, output_config.protocol); + EXPECT_EQ(config.ordered, output_config.ordered); + EXPECT_EQ(config.maxRetransmits, output_config.maxRetransmits); + EXPECT_FALSE(output_config.maxRetransmitTime); +} + +TEST_F(SctpUtilsTest, WriteParseOpenMessageWithPriority) { + webrtc::DataChannelInit config; + std::string label = "abc"; + config.protocol = "y"; + config.priority = webrtc::Priority::kVeryLow; + + rtc::CopyOnWriteBuffer packet; + ASSERT_TRUE(webrtc::WriteDataChannelOpenMessage(label, config, &packet)); + + VerifyOpenMessageFormat(packet, label, config); + + std::string output_label; + webrtc::DataChannelInit output_config; + ASSERT_TRUE(webrtc::ParseDataChannelOpenMessage(packet, &output_label, + &output_config)); + + EXPECT_EQ(label, output_label); + ASSERT_TRUE(output_config.priority); + EXPECT_EQ(*config.priority, *output_config.priority); +} + +TEST_F(SctpUtilsTest, WriteParseAckMessage) { + rtc::CopyOnWriteBuffer packet; + webrtc::WriteDataChannelOpenAckMessage(&packet); + + uint8_t message_type; + rtc::ByteBufferReader buffer(packet.data<char>(), packet.size()); + ASSERT_TRUE(buffer.ReadUInt8(&message_type)); + EXPECT_EQ(0x02, message_type); + + EXPECT_TRUE(webrtc::ParseDataChannelOpenAckMessage(packet)); +} + +TEST_F(SctpUtilsTest, TestIsOpenMessage) { + rtc::CopyOnWriteBuffer open(1); + open.MutableData()[0] = 0x03; + EXPECT_TRUE(webrtc::IsOpenMessage(open)); + + rtc::CopyOnWriteBuffer openAck(1); + openAck.MutableData()[0] = 0x02; + EXPECT_FALSE(webrtc::IsOpenMessage(openAck)); + + rtc::CopyOnWriteBuffer invalid(1); + invalid.MutableData()[0] = 0x01; + EXPECT_FALSE(webrtc::IsOpenMessage(invalid)); + + rtc::CopyOnWriteBuffer empty; + EXPECT_FALSE(webrtc::IsOpenMessage(empty)); +} |