Skip to content

GitLab

T
tangled
Commit d062165a authored by Helen Li's avatar Helen Li Committed by Commit Bot
Browse files
Options

Use base::BindLambdaForTesting in two test files 

Use capturing lambda to make test logic more concise.

Bug: 721401
Cq-Include-Trybots: master.tryserver.chromium.linux:linux_mojo
Change-Id: Ic48af0c91ddc9574fa793540df4059247df005d9
Reviewed-on: https://chromium-review.googlesource.com/1048207
Commit-Queue: Helen Li <xunjieli@chromium.org>
Reviewed-by: default avatarMatt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#557876}
parent f32e98d7
Hide whitespace changes
Inline Side-by-side
Showing with 72 additions and 111 deletions
services/network/tcp_socket_unittest.cc
View file @ d062165a
......@@ -12,6 +12,7 @@
#include "base/logging.h"
#include "base/macros.h"
#include "base/run_loop.h"
#include "base/test/bind_test_util.h"
#include "base/test/scoped_task_environment.h"
#include "base/threading/thread.h"
#include "mojo/public/cpp/system/data_pipe_utils.h"
......@@ -148,17 +149,13 @@ class TestServer {
factory_.CreateTCPServerSocket(
server_addr_, backlog, TRAFFIC_ANNOTATION_FOR_TESTS,
mojo::MakeRequest(&server_socket_),
base::BindOnce(
[](base::RunLoop* run_loop, int* result_out,
net::IPEndPoint* local_addr_out, int result,
const base::Optional<net::IPEndPoint>& local_addr) {
*result_out = result;
base::BindLambdaForTesting(
[&](int result, const base::Optional<net::IPEndPoint>& local_addr) {
net_error = result;
if (local_addr)
*local_addr_out = local_addr.value();
run_loop->Quit();
},
base::Unretained(&run_loop), base::Unretained(&net_error),
base::Unretained(&server_addr_)));
server_addr_ = local_addr.value();
run_loop.Quit();
}));
run_loop.Run();
EXPECT_EQ(net::OK, net_error);
}
......@@ -317,19 +314,15 @@ class TCPSocketTest : public testing::Test {
factory_->CreateTCPConnectedSocket(
local_addr, remote_addr_list, TRAFFIC_ANNOTATION_FOR_TESTS,
std::move(request), std::move(observer),
base::BindOnce(
[](base::RunLoop* run_loop, int* result_out,
mojo::ScopedDataPipeConsumerHandle* consumer_handle,
mojo::ScopedDataPipeProducerHandle* producer_handle, int result,
mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
*result_out = result;
*consumer_handle = std::move(receive_pipe_handle);
*producer_handle = std::move(send_pipe_handle);
run_loop->Quit();
},
base::Unretained(&run_loop), base::Unretained(&net_error),
receive_pipe_handle_out, send_pipe_handle_out));
base::BindLambdaForTesting(
[&](int result,
mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
net_error = result;
*receive_pipe_handle_out = std::move(receive_pipe_handle);
*send_pipe_handle_out = std::move(send_pipe_handle);
run_loop.Quit();
}));
run_loop.Run();
return net_error;
}
......@@ -715,27 +708,21 @@ TEST_P(TCPSocketWithMockSocketTest, ServerAcceptWithObserverReadError) {
std::move(mock_server_socket));
auto callback = std::make_unique<net::TestCompletionCallback>();
mojom::TCPConnectedSocketPtr connected_socket;
mojom::TCPConnectedSocketPtr connected_socket_result;
mojo::ScopedDataPipeConsumerHandle receive_handle;
mojo::ScopedDataPipeProducerHandle send_handle;
server_socket->Accept(
observer()->GetObserverPtr(),
base::BindOnce(
[](net::CompletionOnceCallback callback,
mojom::TCPConnectedSocketPtr* socket_out,
mojo::ScopedDataPipeConsumerHandle* consumer_handle,
mojo::ScopedDataPipeProducerHandle* producer_handle, int result,
const base::Optional<net::IPEndPoint>& remote_addr,
mojom::TCPConnectedSocketPtr connected_socket,
mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
std::move(callback).Run(result);
*socket_out = std::move(connected_socket);
*consumer_handle = std::move(receive_pipe_handle);
*producer_handle = std::move(send_pipe_handle);
},
std::move(callback->callback()), &connected_socket, &receive_handle,
&send_handle));
base::BindLambdaForTesting(
[&](int result, const base::Optional<net::IPEndPoint>& remote_addr,
mojom::TCPConnectedSocketPtr connected_socket,
mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
std::move(callback->callback()).Run(result);
connected_socket_result = std::move(connected_socket);
receive_handle = std::move(receive_pipe_handle);
send_handle = std::move(send_pipe_handle);
}));
EXPECT_EQ(net::OK, callback->WaitForResult());
base::RunLoop().RunUntilIdle();
......@@ -769,27 +756,21 @@ TEST_P(TCPSocketWithMockSocketTest, ServerAcceptWithObserverWriteError) {
std::move(mock_server_socket));
auto callback = std::make_unique<net::TestCompletionCallback>();
mojom::TCPConnectedSocketPtr connected_socket;
mojom::TCPConnectedSocketPtr connected_socket_result;
mojo::ScopedDataPipeConsumerHandle receive_handle;
mojo::ScopedDataPipeProducerHandle send_handle;
server_socket->Accept(
observer()->GetObserverPtr(),
base::BindOnce(
[](net::CompletionOnceCallback callback,
mojom::TCPConnectedSocketPtr* socket_out,
mojo::ScopedDataPipeConsumerHandle* consumer_handle,
mojo::ScopedDataPipeProducerHandle* producer_handle, int result,
const base::Optional<net::IPEndPoint>& remote_addr,
mojom::TCPConnectedSocketPtr connected_socket,
mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
std::move(callback).Run(result);
*socket_out = std::move(connected_socket);
*consumer_handle = std::move(receive_pipe_handle);
*producer_handle = std::move(send_pipe_handle);
},
std::move(callback->callback()), &connected_socket, &receive_handle,
&send_handle));
base::BindLambdaForTesting(
[&](int result, const base::Optional<net::IPEndPoint>& remote_addr,
mojom::TCPConnectedSocketPtr connected_socket,
mojo::ScopedDataPipeConsumerHandle receive_pipe_handle,
mojo::ScopedDataPipeProducerHandle send_pipe_handle) {
std::move(callback->callback()).Run(result);
connected_socket_result = std::move(connected_socket);
receive_handle = std::move(receive_pipe_handle);
send_handle = std::move(send_pipe_handle);
}));
EXPECT_EQ(net::OK, callback->WaitForResult());
const char kTestMsg[] = "abcdefghij";
......
services/network/udp_socket_test_util.cc
View file @ d062165a
......@@ -7,6 +7,7 @@
#include <utility>
#include "base/run_loop.h"
#include "base/test/bind_test_util.h"
#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
#include "testing/gtest/include/gtest/gtest.h"
......@@ -26,18 +27,14 @@ int UDPSocketTestHelper::ConnectSync(const net::IPEndPoint& remote_addr,
int net_error = net::ERR_FAILED;
socket_->get()->Connect(
remote_addr, std::move(options),
base::BindOnce(
[](base::RunLoop* run_loop, int* result_out,
net::IPEndPoint* local_addr_out, int result,
const base::Optional<net::IPEndPoint>& local_addr) {
*result_out = result;
base::BindLambdaForTesting(
[&](int result, const base::Optional<net::IPEndPoint>& local_addr) {
net_error = result;
if (local_addr) {
*local_addr_out = local_addr.value();
}
run_loop->Quit();
},
base::Unretained(&run_loop), base::Unretained(&net_error),
base::Unretained(local_addr_out)));
run_loop.Quit();
}));
run_loop.Run();
return net_error;
}
......@@ -49,18 +46,14 @@ int UDPSocketTestHelper::BindSync(const net::IPEndPoint& local_addr,
int net_error = net::ERR_FAILED;
socket_->get()->Bind(
local_addr, std::move(options),
base::BindOnce(
[](base::RunLoop* run_loop, int* result_out,
net::IPEndPoint* local_addr_out, int result,
const base::Optional<net::IPEndPoint>& local_addr) {
*result_out = result;
base::BindLambdaForTesting(
[&](int result, const base::Optional<net::IPEndPoint>& local_addr) {
net_error = result;
if (local_addr) {
*local_addr_out = local_addr.value();
}
run_loop->Quit();
},
base::Unretained(&run_loop), base::Unretained(&net_error),
base::Unretained(local_addr_out)));
run_loop.Quit();
}));
run_loop.Run();
return net_error;
}
......@@ -72,12 +65,10 @@ int UDPSocketTestHelper::SendToSync(const net::IPEndPoint& remote_addr,
socket_->get()->SendTo(
remote_addr, input,
net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS),
base::BindOnce(
[](base::RunLoop* run_loop, int* result_out, int result) {
*result_out = result;
run_loop->Quit();
},
base::Unretained(&run_loop), base::Unretained(&net_error)));
base::BindLambdaForTesting([&](int result) {
net_error = result;
run_loop.Quit();
}));
run_loop.Run();
return net_error;
}
......@@ -88,12 +79,10 @@ int UDPSocketTestHelper::SendSync(const std::vector<uint8_t>& input) {
socket_->get()->Send(
input,
net::MutableNetworkTrafficAnnotationTag(TRAFFIC_ANNOTATION_FOR_TESTS),
base::BindOnce(
[](base::RunLoop* run_loop, int* result_out, int result) {
*result_out = result;
run_loop->Quit();
},
base::Unretained(&run_loop), base::Unretained(&net_error)));
base::BindLambdaForTesting([&](int result) {
net_error = result;
run_loop.Quit();
}));
run_loop.Run();
return net_error;
}
......@@ -101,14 +90,11 @@ int UDPSocketTestHelper::SendSync(const std::vector<uint8_t>& input) {
int UDPSocketTestHelper::SetBroadcastSync(bool broadcast) {
base::RunLoop run_loop;
int net_error = net::ERR_FAILED;
socket_->get()->SetBroadcast(
broadcast,
base::BindOnce(
[](base::RunLoop* run_loop, int* result_out, int result) {
*result_out = result;
run_loop->Quit();
},
base::Unretained(&run_loop), base::Unretained(&net_error)));
socket_->get()->SetBroadcast(broadcast,
base::BindLambdaForTesting([&](int result) {
net_error = result;
run_loop.Quit();
}));
run_loop.Run();
return net_error;
}
......@@ -116,14 +102,11 @@ int UDPSocketTestHelper::SetBroadcastSync(bool broadcast) {
int UDPSocketTestHelper::JoinGroupSync(const net::IPAddress& group_address) {
base::RunLoop run_loop;
int net_error = net::ERR_FAILED;
socket_->get()->JoinGroup(
group_address,
base::BindOnce(
[](base::RunLoop* run_loop, int* result_out, int result) {
*result_out = result;
run_loop->Quit();
},
base::Unretained(&run_loop), base::Unretained(&net_error)));
socket_->get()->JoinGroup(group_address,
base::BindLambdaForTesting([&](int result) {
net_error = result;
run_loop.Quit();
}));
run_loop.Run();
return net_error;
}
......@@ -131,14 +114,11 @@ int UDPSocketTestHelper::JoinGroupSync(const net::IPAddress& group_address) {
int UDPSocketTestHelper::LeaveGroupSync(const net::IPAddress& group_address) {
base::RunLoop run_loop;
int net_error = net::ERR_FAILED;
socket_->get()->LeaveGroup(
group_address,
base::BindOnce(
[](base::RunLoop* run_loop, int* result_out, int result) {
*result_out = result;
run_loop->Quit();
},
base::Unretained(&run_loop), base::Unretained(&net_error)));
socket_->get()->LeaveGroup(group_address,
base::BindLambdaForTesting([&](int result) {
net_error = result;
run_loop.Quit();
}));
run_loop.Run();
return net_error;
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment