socket_unittest.cc 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198
  1. // Copyright 2020 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 "device/bluetooth/socket.h"
  5. #include <tuple>
  6. #include <vector>
  7. #include "base/callback_helpers.h"
  8. #include "base/location.h"
  9. #include "base/run_loop.h"
  10. #include "base/test/gmock_callback_support.h"
  11. #include "base/test/task_environment.h"
  12. #include "device/bluetooth/bluetooth_socket.h"
  13. #include "device/bluetooth/test/fake_bluetooth_socket.h"
  14. #include "mojo/public/cpp/system/simple_watcher.h"
  15. #include "net/base/io_buffer.h"
  16. #include "testing/gmock/include/gmock/gmock.h"
  17. #include "testing/gtest/include/gtest/gtest.h"
  18. #include "third_party/abseil-cpp/absl/types/optional.h"
  19. namespace bluetooth {
  20. class SocketTest : public testing::Test {
  21. public:
  22. SocketTest() = default;
  23. ~SocketTest() override = default;
  24. SocketTest(const SocketTest&) = delete;
  25. SocketTest& operator=(const SocketTest&) = delete;
  26. void SetUp() override {
  27. mojo::ScopedDataPipeProducerHandle receive_pipe_producer_handle;
  28. mojo::ScopedDataPipeConsumerHandle receive_pipe_consumer_handle;
  29. ASSERT_EQ(
  30. MOJO_RESULT_OK,
  31. mojo::CreateDataPipe(/*options=*/nullptr, receive_pipe_producer_handle,
  32. receive_pipe_consumer_handle));
  33. mojo::ScopedDataPipeProducerHandle send_pipe_producer_handle;
  34. mojo::ScopedDataPipeConsumerHandle send_pipe_consumer_handle;
  35. ASSERT_EQ(MOJO_RESULT_OK, mojo::CreateDataPipe(/*options=*/nullptr,
  36. send_pipe_producer_handle,
  37. send_pipe_consumer_handle));
  38. receive_stream_ = std::move(receive_pipe_consumer_handle);
  39. send_stream_ = std::move(send_pipe_producer_handle);
  40. fake_bluetooth_socket_ =
  41. base::MakeRefCounted<device::FakeBluetoothSocket>();
  42. socket_ = std::make_unique<Socket>(fake_bluetooth_socket_,
  43. std::move(receive_pipe_producer_handle),
  44. std::move(send_pipe_consumer_handle));
  45. }
  46. void VerifyReceiveAndRead(const std::string& message, bool success) {
  47. EXPECT_FALSE(receive_stream_->QuerySignalsState().never_readable());
  48. // Socket should only have 1 outstanding invocation of
  49. // BluetoothSocket::Receive().
  50. EXPECT_TRUE(fake_bluetooth_socket_->HasReceiveArgs());
  51. auto receive_args = fake_bluetooth_socket_->TakeReceiveArgs();
  52. EXPECT_FALSE(fake_bluetooth_socket_->HasReceiveArgs());
  53. int max_buffer_size = std::get<0>(*receive_args);
  54. EXPECT_GT(max_buffer_size, 0);
  55. // Attempting to read from |receive_stream_| before the BluetoothSocket
  56. // provides received data should signal a MOJO_RESULT_SHOULD_WAIT result.
  57. uint32_t buffer_size = static_cast<uint32_t>(max_buffer_size);
  58. EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
  59. receive_stream_->ReadData(nullptr, &buffer_size,
  60. MOJO_READ_DATA_FLAG_NONE));
  61. if (success) {
  62. // Emulate a successful response from the remote device on the other side
  63. // of the BluetoothSocket. |receive_stream_| should then be ready to be
  64. // read from.
  65. auto success_callback = std::move(std::get<1>(*receive_args));
  66. std::move(success_callback)
  67. .Run(
  68. /*num_bytes_received=*/message.size(),
  69. /*io_buffer=*/base::MakeRefCounted<net::StringIOBuffer>(message));
  70. std::vector<char> buffer(max_buffer_size);
  71. EXPECT_EQ(MOJO_RESULT_OK,
  72. receive_stream_->ReadData(buffer.data(), &buffer_size,
  73. MOJO_READ_DATA_FLAG_NONE));
  74. std::string received_string(buffer.data(), buffer_size);
  75. EXPECT_EQ(message, received_string);
  76. } else {
  77. // Emulate an error in the stack. We should not be able to read from
  78. // |receive_stream_|.
  79. auto error_callback = std::move(std::get<2>(*receive_args));
  80. std::move(error_callback)
  81. .Run(device::BluetoothSocket::ErrorReason::kSystemError, "Error");
  82. }
  83. // Socket should only invoke BluetoothSocket::Receive() if it received
  84. // a success callback from the previous invocation.
  85. EXPECT_EQ(success, fake_bluetooth_socket_->HasReceiveArgs());
  86. // |receive_stream_| should only remain readable if Socket received a
  87. // success callback.
  88. EXPECT_EQ(success, !receive_stream_->QuerySignalsState().never_readable());
  89. }
  90. void WriteAndVerifySend(const std::string& message, bool success) {
  91. EXPECT_FALSE(send_stream_->QuerySignalsState().never_writable());
  92. // Verify that Socket has not attempted to invoke BluetoothSocket::Send(),
  93. // because no bytes have been written over |send_stream_| yet.
  94. EXPECT_FALSE(fake_bluetooth_socket_->HasSendArgs());
  95. uint32_t message_size = message.size();
  96. EXPECT_EQ(MOJO_RESULT_OK,
  97. send_stream_->WriteData(message.data(), &message_size,
  98. MOJO_WRITE_DATA_FLAG_NONE));
  99. EXPECT_EQ(message.size(), message_size);
  100. // Allow Socket to be notified that it can now read |send_stream_|.
  101. base::RunLoop().RunUntilIdle();
  102. // Socket should have now attempted to send our |message| to the remote
  103. // device on the other side of the BluetoothSocket.
  104. EXPECT_TRUE(fake_bluetooth_socket_->HasSendArgs());
  105. auto send_args = fake_bluetooth_socket_->TakeSendArgs();
  106. int buffer_size = std::get<1>(*send_args);
  107. EXPECT_EQ(message_size, static_cast<uint32_t>(buffer_size));
  108. char* buffer = std::get<0>(*send_args)->data();
  109. std::string sent_string(buffer, buffer_size);
  110. EXPECT_EQ(message, sent_string);
  111. if (success) {
  112. auto success_callback = std::move(std::get<2>(*send_args));
  113. std::move(success_callback).Run(/*num_bytes_sent=*/message.size());
  114. } else {
  115. auto error_callback = std::move(std::get<3>(*send_args));
  116. std::move(error_callback).Run(/*error_message=*/"Error");
  117. }
  118. // Never expect an outstanding invocation of BluetoothSocket::Send().
  119. EXPECT_FALSE(fake_bluetooth_socket_->HasSendArgs());
  120. // |send_stream_| should only remain writeable if Socket received a success
  121. // callback.
  122. EXPECT_EQ(success, !send_stream_->QuerySignalsState().never_writable());
  123. }
  124. protected:
  125. scoped_refptr<device::FakeBluetoothSocket> fake_bluetooth_socket_;
  126. mojo::ScopedDataPipeConsumerHandle receive_stream_;
  127. mojo::ScopedDataPipeProducerHandle send_stream_;
  128. std::unique_ptr<Socket> socket_;
  129. private:
  130. base::test::SingleThreadTaskEnvironment task_environment;
  131. };
  132. TEST_F(SocketTest, TestOnDestroyCallsClose) {
  133. // When destroyed, |socket_| is expected to tear down its BluetoothSocket.
  134. socket_.reset();
  135. EXPECT_TRUE(fake_bluetooth_socket_->called_disconnect());
  136. }
  137. TEST_F(SocketTest, TestDisconnect) {
  138. socket_->Disconnect(base::DoNothing());
  139. EXPECT_TRUE(fake_bluetooth_socket_->called_disconnect());
  140. }
  141. TEST_F(SocketTest, TestReceive_Success) {
  142. VerifyReceiveAndRead("received_message", /*success=*/true);
  143. }
  144. TEST_F(SocketTest, TestReceive_Error) {
  145. VerifyReceiveAndRead("received_message", /*success=*/false);
  146. }
  147. TEST_F(SocketTest, TestSend_Success) {
  148. WriteAndVerifySend("sent_message", /*success=*/true);
  149. }
  150. TEST_F(SocketTest, TestSend_Error) {
  151. WriteAndVerifySend("sent_message", /*success=*/false);
  152. }
  153. TEST_F(SocketTest, TestReceiveAndSendMultiple) {
  154. VerifyReceiveAndRead("message_1", /*success=*/true);
  155. VerifyReceiveAndRead("message_2", /*success=*/true);
  156. WriteAndVerifySend("message_3", /*success=*/true);
  157. WriteAndVerifySend("message_4", /*success=*/true);
  158. VerifyReceiveAndRead("message_5", /*success=*/true);
  159. WriteAndVerifySend("message_6", /*success=*/true);
  160. }
  161. } // namespace bluetooth