udp_transport_unittest.cc 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165
  1. // Copyright 2014 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. #include "media/cast/net/udp_transport_impl.h"
  5. #include <algorithm>
  6. #include <memory>
  7. #include <string>
  8. #include <vector>
  9. #include "base/bind.h"
  10. #include "base/callback.h"
  11. #include "base/run_loop.h"
  12. #include "base/test/mock_callback.h"
  13. #include "base/test/task_environment.h"
  14. #include "media/cast/net/cast_transport_config.h"
  15. #include "media/cast/net/udp_packet_pipe.h"
  16. #include "media/cast/test/utility/net_utility.h"
  17. #include "net/base/ip_address.h"
  18. #include "testing/gtest/include/gtest/gtest.h"
  19. namespace media {
  20. namespace cast {
  21. namespace {
  22. class MockPacketReceiver final : public UdpTransportReceiver {
  23. public:
  24. MockPacketReceiver(const base::RepeatingClosure& callback)
  25. : packet_callback_(callback) {}
  26. MockPacketReceiver(const MockPacketReceiver&) = delete;
  27. MockPacketReceiver& operator=(const MockPacketReceiver&) = delete;
  28. bool ReceivedPacket(std::unique_ptr<Packet> packet) {
  29. packet_ = std::move(packet);
  30. packet_callback_.Run();
  31. return true;
  32. }
  33. // UdpTransportReceiver implementation.
  34. void OnPacketReceived(const std::vector<uint8_t>& packet) override {
  35. EXPECT_GT(packet.size(), 0u);
  36. packet_ = std::make_unique<Packet>(packet);
  37. packet_callback_.Run();
  38. }
  39. PacketReceiverCallbackWithStatus packet_receiver() {
  40. return base::BindRepeating(&MockPacketReceiver::ReceivedPacket,
  41. base::Unretained(this));
  42. }
  43. std::unique_ptr<Packet> TakePacket() { return std::move(packet_); }
  44. private:
  45. base::RepeatingClosure packet_callback_;
  46. std::unique_ptr<Packet> packet_;
  47. };
  48. void SendPacket(UdpTransportImpl* transport, Packet packet) {
  49. transport->SendPacket(new base::RefCountedData<Packet>(packet),
  50. base::OnceClosure());
  51. }
  52. static void UpdateCastTransportStatus(CastTransportStatus status) {
  53. NOTREACHED();
  54. }
  55. } // namespace
  56. class UdpTransportImplTest : public ::testing::Test {
  57. public:
  58. UdpTransportImplTest()
  59. : task_environment_(base::test::TaskEnvironment::MainThreadType::IO) {
  60. net::IPEndPoint free_local_port1 = test::GetFreeLocalPort();
  61. net::IPEndPoint free_local_port2 = test::GetFreeLocalPort();
  62. send_transport_ = std::make_unique<UdpTransportImpl>(
  63. task_environment_.GetMainThreadTaskRunner(), free_local_port1,
  64. free_local_port2, base::BindRepeating(&UpdateCastTransportStatus));
  65. send_transport_->SetSendBufferSize(65536);
  66. recv_transport_ = std::make_unique<UdpTransportImpl>(
  67. task_environment_.GetMainThreadTaskRunner(), free_local_port2,
  68. free_local_port1, base::BindRepeating(&UpdateCastTransportStatus));
  69. recv_transport_->SetSendBufferSize(65536);
  70. }
  71. UdpTransportImplTest(const UdpTransportImplTest&) = delete;
  72. UdpTransportImplTest& operator=(const UdpTransportImplTest&) = delete;
  73. ~UdpTransportImplTest() override = default;
  74. protected:
  75. base::test::TaskEnvironment task_environment_;
  76. std::unique_ptr<UdpTransportImpl> send_transport_;
  77. // A receiver side transport to receiver/send packets from/to sender.
  78. std::unique_ptr<UdpTransportImpl> recv_transport_;
  79. };
  80. // Test the sending/receiving functions as a PacketSender.
  81. TEST_F(UdpTransportImplTest, PacketSenderSendAndReceive) {
  82. std::string data = "Test";
  83. Packet packet(data.begin(), data.end());
  84. base::RunLoop run_loop;
  85. MockPacketReceiver packet_receiver_on_sender(run_loop.QuitClosure());
  86. MockPacketReceiver packet_receiver_on_receiver(
  87. base::BindRepeating(&SendPacket, recv_transport_.get(), packet));
  88. send_transport_->StartReceiving(packet_receiver_on_sender.packet_receiver());
  89. recv_transport_->StartReceiving(
  90. packet_receiver_on_receiver.packet_receiver());
  91. SendPacket(send_transport_.get(), packet);
  92. run_loop.Run();
  93. std::unique_ptr<Packet> received_packet =
  94. packet_receiver_on_sender.TakePacket();
  95. EXPECT_TRUE(received_packet);
  96. EXPECT_TRUE(
  97. std::equal(packet.begin(), packet.end(), received_packet->begin()));
  98. received_packet = packet_receiver_on_receiver.TakePacket();
  99. EXPECT_TRUE(received_packet);
  100. EXPECT_TRUE(
  101. std::equal(packet.begin(), packet.end(), (*received_packet).begin()));
  102. }
  103. // Test the sending/receiving functions as a UdpTransport.
  104. TEST_F(UdpTransportImplTest, UdpTransportSendAndReceive) {
  105. std::string data = "Hello!";
  106. Packet packet(data.begin(), data.end());
  107. base::RunLoop run_loop;
  108. MockPacketReceiver packet_receiver_on_sender(run_loop.QuitClosure());
  109. MockPacketReceiver packet_receiver_on_receiver(
  110. base::BindRepeating(&SendPacket, recv_transport_.get(), packet));
  111. send_transport_->StartReceiving(&packet_receiver_on_sender);
  112. recv_transport_->StartReceiving(
  113. packet_receiver_on_receiver.packet_receiver());
  114. mojo::ScopedDataPipeProducerHandle producer_handle;
  115. mojo::ScopedDataPipeConsumerHandle consumer_handle;
  116. ASSERT_EQ(mojo::CreateDataPipe(5, producer_handle, consumer_handle),
  117. MOJO_RESULT_OK);
  118. send_transport_->StartSending(std::move(consumer_handle));
  119. UdpPacketPipeWriter writer(std::move(producer_handle));
  120. base::MockCallback<base::OnceClosure> done_callback;
  121. EXPECT_CALL(done_callback, Run()).Times(1);
  122. writer.Write(new base::RefCountedData<Packet>(packet), done_callback.Get());
  123. run_loop.Run();
  124. std::unique_ptr<Packet> received_packet =
  125. packet_receiver_on_sender.TakePacket();
  126. EXPECT_TRUE(received_packet);
  127. EXPECT_TRUE(
  128. std::equal(packet.begin(), packet.end(), received_packet->begin()));
  129. received_packet = packet_receiver_on_receiver.TakePacket();
  130. EXPECT_TRUE(received_packet);
  131. EXPECT_TRUE(
  132. std::equal(packet.begin(), packet.end(), (*received_packet).begin()));
  133. }
  134. } // namespace cast
  135. } // namespace media