fake_stream_socket_unittest.cc 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137
  1. // Copyright 2016 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 <stdint.h>
  5. #include <cstring>
  6. #include <string>
  7. #include "base/bind.h"
  8. #include "base/check.h"
  9. #include "base/memory/ref_counted.h"
  10. #include "base/test/task_environment.h"
  11. #include "chromecast/net/fake_stream_socket.h"
  12. #include "net/base/io_buffer.h"
  13. #include "net/base/ip_endpoint.h"
  14. #include "net/base/net_errors.h"
  15. #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
  16. #include "testing/gtest/include/gtest/gtest.h"
  17. namespace chromecast {
  18. namespace {
  19. const char kIpAddress1[] = "192.168.0.1";
  20. const uint16_t kPort1 = 10001;
  21. const char kIpAddress2[] = "192.168.0.2";
  22. const uint16_t kPort2 = 10002;
  23. net::IPAddress IpLiteralToIpAddress(const std::string& ip_literal) {
  24. net::IPAddress ip_address;
  25. CHECK(ip_address.AssignFromIPLiteral(ip_literal));
  26. return ip_address;
  27. }
  28. void Callback(int error_code) {}
  29. } // namespace
  30. class FakeStreamSocketTest : public ::testing::Test {
  31. public:
  32. FakeStreamSocketTest()
  33. : endpoint_1_(IpLiteralToIpAddress(kIpAddress1), kPort1),
  34. socket_1_(endpoint_1_),
  35. endpoint_2_(IpLiteralToIpAddress(kIpAddress2), kPort2),
  36. socket_2_(endpoint_2_) {}
  37. ~FakeStreamSocketTest() override {}
  38. base::test::TaskEnvironment task_environment_;
  39. net::IPEndPoint endpoint_1_;
  40. FakeStreamSocket socket_1_;
  41. net::IPEndPoint endpoint_2_;
  42. FakeStreamSocket socket_2_;
  43. };
  44. TEST_F(FakeStreamSocketTest, GetLocalAddress) {
  45. net::IPEndPoint local_address;
  46. ASSERT_EQ(net::OK, socket_1_.GetLocalAddress(&local_address));
  47. EXPECT_EQ(endpoint_1_, local_address);
  48. }
  49. TEST_F(FakeStreamSocketTest, GetPeerAddressWithoutPeer) {
  50. net::IPEndPoint peer_address;
  51. EXPECT_EQ(net::ERR_SOCKET_NOT_CONNECTED,
  52. socket_1_.GetPeerAddress(&peer_address));
  53. }
  54. TEST_F(FakeStreamSocketTest, GetPeerAddressWithPeer) {
  55. socket_1_.SetPeer(&socket_2_);
  56. socket_2_.SetPeer(&socket_1_);
  57. net::IPEndPoint peer_address;
  58. ASSERT_EQ(net::OK, socket_1_.GetPeerAddress(&peer_address));
  59. EXPECT_EQ(endpoint_2_, peer_address);
  60. }
  61. TEST_F(FakeStreamSocketTest, ReadAndWriteWithoutPeer) {
  62. auto io_buffer = base::MakeRefCounted<net::IOBuffer>(1);
  63. EXPECT_EQ(net::ERR_IO_PENDING,
  64. socket_1_.Read(io_buffer.get(), 1, base::BindOnce(&Callback)));
  65. EXPECT_EQ(net::ERR_SOCKET_NOT_CONNECTED,
  66. socket_1_.Write(io_buffer.get(), 1, base::BindOnce(&Callback),
  67. TRAFFIC_ANNOTATION_FOR_TESTS));
  68. }
  69. TEST_F(FakeStreamSocketTest, ReadAndWriteWithPeer) {
  70. socket_1_.SetPeer(&socket_2_);
  71. socket_2_.SetPeer(&socket_1_);
  72. const std::string kData("DATA");
  73. auto send_buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
  74. ASSERT_EQ(
  75. static_cast<int>(kData.size()),
  76. socket_1_.Write(send_buffer.get(), kData.size(),
  77. base::BindOnce(&Callback), TRAFFIC_ANNOTATION_FOR_TESTS));
  78. auto receive_buffer = base::MakeRefCounted<net::IOBuffer>(kData.size());
  79. ASSERT_EQ(static_cast<int>(kData.size()),
  80. socket_2_.Read(receive_buffer.get(), kData.size(),
  81. base::BindOnce(&Callback)));
  82. EXPECT_EQ(0, std::memcmp(kData.data(), receive_buffer->data(), kData.size()));
  83. }
  84. TEST_F(FakeStreamSocketTest, ReadAndWritePending) {
  85. socket_1_.SetPeer(&socket_2_);
  86. socket_2_.SetPeer(&socket_1_);
  87. const std::string kData("DATA");
  88. auto receive_buffer = base::MakeRefCounted<net::IOBuffer>(kData.size());
  89. ASSERT_EQ(net::ERR_IO_PENDING,
  90. socket_2_.Read(receive_buffer.get(), kData.size(),
  91. base::BindOnce(&Callback)));
  92. auto send_buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
  93. ASSERT_EQ(
  94. static_cast<int>(kData.size()),
  95. socket_1_.Write(send_buffer.get(), kData.size(),
  96. base::BindOnce(&Callback), TRAFFIC_ANNOTATION_FOR_TESTS));
  97. EXPECT_EQ(0, std::memcmp(kData.data(), receive_buffer->data(), kData.size()));
  98. }
  99. TEST_F(FakeStreamSocketTest, ReadAndWriteLargeData) {
  100. socket_1_.SetPeer(&socket_2_);
  101. socket_2_.SetPeer(&socket_1_);
  102. // Send 1 MB of data between sockets.
  103. const std::string kData("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdef");
  104. auto send_buffer = base::MakeRefCounted<net::StringIOBuffer>(kData);
  105. const int kWriteCount = 1024 * 1024 / kData.size();
  106. for (int i = 0; i < kWriteCount; i++) {
  107. ASSERT_EQ(static_cast<int>(kData.size()),
  108. socket_1_.Write(send_buffer.get(), kData.size(),
  109. base::BindOnce(&Callback),
  110. TRAFFIC_ANNOTATION_FOR_TESTS));
  111. }
  112. auto receive_buffer = base::MakeRefCounted<net::IOBuffer>(1024);
  113. for (int i = 0; i < 1024; i++) {
  114. ASSERT_EQ(1024, socket_2_.Read(receive_buffer.get(), 1024,
  115. base::BindOnce(&Callback)));
  116. }
  117. }
  118. } // namespace chromecast