natas_hw
/
grpc
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #4720 from sreecha/import_issues 

Rename TestService to EchoTestService to prevent name-conflict with 'TestService' in test.proto
This commit is contained in:
Yang Gao 2016-01-14 09:16:56 -08:00
parent ac3d328fa9 b0d0c8e8c2
commit cd0683330e
16 changed files with 106 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/proto/grpc/testing/duplicate/echo_duplicate.proto
View File

@ -36,6 +36,6 @@ import "src/proto/grpc/testing/echo_messages.proto";
package grpc.testing.duplicate;
service TestService {
service EchoTestService {
rpc Echo(grpc.testing.EchoRequest) returns (grpc.testing.EchoResponse);
}

2
src/proto/grpc/testing/echo.proto
View File

@ -34,7 +34,7 @@ import "src/proto/grpc/testing/echo_messages.proto";
package grpc.testing;
service TestService {
service EchoTestService {
rpc Echo(EchoRequest) returns (EchoResponse);
rpc RequestStream(stream EchoRequest) returns (EchoResponse);
rpc ResponseStream(EchoRequest) returns (stream EchoResponse);

18
test/cpp/end2end/async_end2end_test.cc
View File

@ -33,21 +33,21 @@
#include <memory>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
#include <grpc++/create_channel.h>
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
#include <grpc++/server_context.h>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <gtest/gtest.h>
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
#include "test/cpp/util/string_ref_helper.h"
#ifdef GPR_POSIX_SOCKET
@ -186,7 +186,7 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<bool> {
build_bad.AddListeningPort(server_address_.str(),
grpc::InsecureServerCredentials());
build_bad.RegisterAsyncService(&service_);
grpc::testing::TestService::Service sync_service;
grpc::testing::EchoTestService::Service sync_service;
build_bad.RegisterService(&sync_service);
GPR_ASSERT(build_bad.BuildAndStart() == nullptr);
@ -211,7 +211,7 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<bool> {
void ResetStub() {
std::shared_ptr<Channel> channel =
CreateChannel(server_address_.str(), InsecureChannelCredentials());
stub_ = grpc::testing::TestService::NewStub(channel);
stub_ = grpc::testing::EchoTestService::NewStub(channel);
}
void SendRpc(int num_rpcs) {
@ -249,9 +249,9 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<bool> {
}
std::unique_ptr<ServerCompletionQueue> cq_;
std::unique_ptr<grpc::testing::TestService::Stub> stub_;
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<Server> server_;
grpc::testing::TestService::AsyncService service_;
grpc::testing::EchoTestService::AsyncService service_;
std::ostringstream server_address_;
};

14
test/cpp/end2end/client_crash_test.cc
View File

@ -31,21 +31,21 @@
*
*/
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
#include <grpc++/create_channel.h>
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
#include <grpc++/server_context.h>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <gtest/gtest.h>
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
#include "test/cpp/util/subprocess.h"
using grpc::testing::EchoRequest;
@ -63,7 +63,7 @@ class CrashTest : public ::testing::Test {
protected:
CrashTest() {}
std::unique_ptr<grpc::testing::TestService::Stub> CreateServerAndStub() {
std::unique_ptr<grpc::testing::EchoTestService::Stub> CreateServerAndStub() {
auto port = grpc_pick_unused_port_or_die();
std::ostringstream addr_stream;
addr_stream << "localhost:" << port;
@ -72,7 +72,7 @@ class CrashTest : public ::testing::Test {
g_root + "/client_crash_test_server", "--address=" + addr,
}));
GPR_ASSERT(server_);
return grpc::testing::TestService::NewStub(
return grpc::testing::EchoTestService::NewStub(
CreateChannel(addr, InsecureChannelCredentials()));
}

5
test/cpp/end2end/client_crash_test_server.cc
View File

@ -31,10 +31,10 @@
*
*/
#include <gflags/gflags.h>
#include <iostream>
#include <memory>
#include <string>
#include <gflags/gflags.h>
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
@ -56,7 +56,8 @@ using namespace gflags;
namespace grpc {
namespace testing {
class ServiceImpl GRPC_FINAL : public ::grpc::testing::TestService::Service {
class ServiceImpl GRPC_FINAL
: public ::grpc::testing::EchoTestService::Service {
Status BidiStream(ServerContext* context,
ServerReaderWriter<EchoResponse, EchoRequest>* stream)
GRPC_OVERRIDE {

30
test/cpp/end2end/end2end_test.cc
View File

@ -34,9 +34,6 @@
#include <mutex>
#include <thread>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
#include <grpc++/create_channel.h>
@ -46,14 +43,17 @@
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
#include <grpc++/server_context.h>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <gtest/gtest.h>
#include "src/core/security/credentials.h"
#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/end2end/data/ssl_test_data.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/cpp/util/string_ref_helper.h"
using grpc::testing::EchoRequest;
@ -196,10 +196,10 @@ class TestAuthMetadataProcessor : public AuthMetadataProcessor {
const char TestAuthMetadataProcessor::kGoodGuy[] = "Dr Jekyll";
const char TestAuthMetadataProcessor::kIdentityPropName[] = "novel identity";
class Proxy : public ::grpc::testing::TestService::Service {
class Proxy : public ::grpc::testing::EchoTestService::Service {
public:
Proxy(std::shared_ptr<Channel> channel)
: stub_(grpc::testing::TestService::NewStub(channel)) {}
: stub_(grpc::testing::EchoTestService::NewStub(channel)) {}
Status Echo(ServerContext* server_context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE {
@ -209,10 +209,10 @@ class Proxy : public ::grpc::testing::TestService::Service {
}
private:
std::unique_ptr< ::grpc::testing::TestService::Stub> stub_;
std::unique_ptr< ::grpc::testing::EchoTestService::Stub> stub_;
};
class TestServiceImpl : public ::grpc::testing::TestService::Service {
class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
public:
TestServiceImpl() : signal_client_(false), host_() {}
explicit TestServiceImpl(const grpc::string& host)
@ -344,7 +344,7 @@ class TestServiceImpl : public ::grpc::testing::TestService::Service {
};
class TestServiceImplDupPkg
: public ::grpc::testing::duplicate::TestService::Service {
: public ::grpc::testing::duplicate::EchoTestService::Service {
public:
Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE {
@ -435,12 +435,12 @@ class End2endTest : public ::testing::TestWithParam<TestScenario> {
channel_ = CreateChannel(proxyaddr.str(), InsecureChannelCredentials());
}
stub_ = grpc::testing::TestService::NewStub(channel_);
stub_ = grpc::testing::EchoTestService::NewStub(channel_);
}
bool is_server_started_;
std::shared_ptr<Channel> channel_;
std::unique_ptr<grpc::testing::TestService::Stub> stub_;
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<Server> server_;
std::unique_ptr<Server> proxy_server_;
std::unique_ptr<Proxy> proxy_service_;
@ -451,7 +451,7 @@ class End2endTest : public ::testing::TestWithParam<TestScenario> {
TestServiceImplDupPkg dup_pkg_service_;
};
static void SendRpc(grpc::testing::TestService::Stub* stub, int num_rpcs) {
static void SendRpc(grpc::testing::EchoTestService::Stub* stub, int num_rpcs) {
EchoRequest request;
EchoResponse response;
request.set_message("Hello hello hello hello");
@ -561,8 +561,8 @@ TEST_P(End2endTest, DiffPackageServices) {
EXPECT_EQ(response.message(), request.message());
EXPECT_TRUE(s.ok());
std::unique_ptr<grpc::testing::duplicate::TestService::Stub> dup_pkg_stub(
grpc::testing::duplicate::TestService::NewStub(channel_));
std::unique_ptr<grpc::testing::duplicate::EchoTestService::Stub> dup_pkg_stub(
grpc::testing::duplicate::EchoTestService::NewStub(channel_));
ClientContext context2;
s = dup_pkg_stub->Echo(&context2, request, &response);
EXPECT_EQ("no package", response.message());

17
test/cpp/end2end/generic_end2end_test.cc
View File

@ -33,24 +33,24 @@
#include <memory>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <grpc++/impl/proto_utils.h>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
#include <grpc++/create_channel.h>
#include <grpc++/generic/async_generic_service.h>
#include <grpc++/generic/generic_stub.h>
#include <grpc++/impl/proto_utils.h>
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
#include <grpc++/server_context.h>
#include <grpc++/support/slice.h>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <gtest/gtest.h>
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
using grpc::testing::EchoRequest;
using grpc::testing::EchoResponse;
@ -134,7 +134,7 @@ class GenericEnd2endTest : public ::testing::Test {
void client_fail(int i) { verify_ok(&cli_cq_, i, false); }
void SendRpc(int num_rpcs) {
const grpc::string kMethodName("/grpc.cpp.test.util.TestService/Echo");
const grpc::string kMethodName("/grpc.cpp.test.util.EchoTestService/Echo");
for (int i = 0; i < num_rpcs; i++) {
EchoRequest send_request;
EchoRequest recv_request;
@ -193,7 +193,7 @@ class GenericEnd2endTest : public ::testing::Test {
CompletionQueue cli_cq_;
std::unique_ptr<ServerCompletionQueue> srv_cq_;
std::unique_ptr<grpc::testing::TestService::Stub> stub_;
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<grpc::GenericStub> generic_stub_;
std::unique_ptr<Server> server_;
AsyncGenericService generic_service_;
@ -215,7 +215,8 @@ TEST_F(GenericEnd2endTest, SequentialRpcs) {
TEST_F(GenericEnd2endTest, SimpleBidiStreaming) {
ResetStub();
const grpc::string kMethodName("/grpc.cpp.test.util.TestService/BidiStream");
const grpc::string kMethodName(
"/grpc.cpp.test.util.EchoTestService/BidiStream");
EchoRequest send_request;
EchoRequest recv_request;
EchoResponse send_response;

26
test/cpp/end2end/mock_test.cc
View File

@ -33,25 +33,25 @@
#include <thread>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
#include <grpc++/create_channel.h>
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
#include <grpc++/server_context.h>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <gtest/gtest.h>
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
using grpc::testing::EchoRequest;
using grpc::testing::EchoResponse;
using grpc::testing::TestService;
using grpc::testing::EchoTestService;
using std::chrono::system_clock;
namespace grpc {
@ -98,7 +98,7 @@ class MockClientReaderWriter<EchoRequest, EchoResponse> GRPC_FINAL
};
// Mocked stub.
class MockStub : public TestService::StubInterface {
class MockStub : public EchoTestService::StubInterface {
public:
MockStub() {}
~MockStub() {}
@ -154,7 +154,7 @@ class MockStub : public TestService::StubInterface {
class FakeClient {
public:
explicit FakeClient(TestService::StubInterface* stub) : stub_(stub) {}
explicit FakeClient(EchoTestService::StubInterface* stub) : stub_(stub) {}
void DoEcho() {
ClientContext context;
@ -197,13 +197,13 @@ class FakeClient {
EXPECT_TRUE(s.ok());
}
void ResetStub(TestService::StubInterface* stub) { stub_ = stub; }
void ResetStub(EchoTestService::StubInterface* stub) { stub_ = stub; }
private:
TestService::StubInterface* stub_;
EchoTestService::StubInterface* stub_;
};
class TestServiceImpl : public TestService::Service {
class TestServiceImpl : public EchoTestService::Service {
public:
Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE {
@ -245,10 +245,10 @@ class MockTest : public ::testing::Test {
void ResetStub() {
std::shared_ptr<Channel> channel =
CreateChannel(server_address_.str(), InsecureChannelCredentials());
stub_ = grpc::testing::TestService::NewStub(channel);
stub_ = grpc::testing::EchoTestService::NewStub(channel);
}
std::unique_ptr<grpc::testing::TestService::Stub> stub_;
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<Server> server_;
std::ostringstream server_address_;
TestServiceImpl service_;

13
test/cpp/end2end/server_crash_test.cc
View File

@ -31,21 +31,21 @@
*
*/
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
#include <grpc++/create_channel.h>
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
#include <grpc++/server_context.h>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <gtest/gtest.h>
#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
#include "test/cpp/util/subprocess.h"
using grpc::testing::EchoRequest;
@ -59,7 +59,8 @@ namespace testing {
namespace {
class ServiceImpl GRPC_FINAL : public ::grpc::testing::TestService::Service {
class ServiceImpl GRPC_FINAL
: public ::grpc::testing::EchoTestService::Service {
public:
ServiceImpl() : bidi_stream_count_(0), response_stream_count_(0) {}

4
test/cpp/end2end/server_crash_test_client.cc
View File

@ -31,11 +31,11 @@
*
*/
#include <gflags/gflags.h>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
#include <gflags/gflags.h>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
@ -57,7 +57,7 @@ using namespace gflags;
int main(int argc, char** argv) {
ParseCommandLineFlags(&argc, &argv, true);
auto stub = grpc::testing::TestService::NewStub(
auto stub = grpc::testing::EchoTestService::NewStub(
grpc::CreateChannel(FLAGS_address, grpc::InsecureChannelCredentials()));
EchoRequest request;

14
test/cpp/end2end/shutdown_test.cc
View File

@ -33,20 +33,20 @@
#include <thread>
#include <grpc/grpc.h>
#include <grpc/support/sync.h>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
#include <grpc++/create_channel.h>
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
#include <grpc++/server_context.h>
#include <grpc/grpc.h>
#include <grpc/support/sync.h>
#include <gtest/gtest.h>
#include "src/core/support/env.h"
#include "test/core/util/test_config.h"
#include "test/core/util/port.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
using grpc::testing::EchoRequest;
using grpc::testing::EchoResponse;
@ -54,7 +54,7 @@ using grpc::testing::EchoResponse;
namespace grpc {
namespace testing {
class TestServiceImpl : public ::grpc::testing::TestService::Service {
class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
public:
explicit TestServiceImpl(gpr_event* ev) : ev_(ev) {}
@ -94,7 +94,7 @@ class ShutdownTest : public ::testing::Test {
void ResetStub() {
string target = "dns:localhost:" + to_string(port_);
channel_ = CreateChannel(target, InsecureChannelCredentials());
stub_ = grpc::testing::TestService::NewStub(channel_);
stub_ = grpc::testing::EchoTestService::NewStub(channel_);
}
string to_string(const int number) {
@ -115,7 +115,7 @@ class ShutdownTest : public ::testing::Test {
protected:
std::shared_ptr<Channel> channel_;
std::unique_ptr<grpc::testing::TestService::Stub> stub_;
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<Server> server_;
bool shutdown_;
int port_;

12
test/cpp/end2end/streaming_throughput_test.cc
View File

@ -31,9 +31,9 @@
*
*/
#include <time.h>
#include <mutex>
#include <thread>
#include <time.h>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
@ -49,10 +49,10 @@
#include <grpc/support/time.h>
#include <gtest/gtest.h>
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
using grpc::testing::EchoRequest;
using grpc::testing::EchoResponse;
@ -99,7 +99,7 @@ const char* kLargeString =
namespace grpc {
namespace testing {
class TestServiceImpl : public ::grpc::testing::TestService::Service {
class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
public:
static void BidiStream_Sender(
ServerReaderWriter<EchoResponse, EchoRequest>* stream,
@ -161,10 +161,10 @@ class End2endTest : public ::testing::Test {
void ResetStub() {
std::shared_ptr<Channel> channel =
CreateChannel(server_address_.str(), InsecureChannelCredentials());
stub_ = grpc::testing::TestService::NewStub(channel);
stub_ = grpc::testing::EchoTestService::NewStub(channel);
}
std::unique_ptr<grpc::testing::TestService::Stub> stub_;
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<Server> server_;
std::ostringstream server_address_;
TestServiceImpl service_;

20
test/cpp/end2end/thread_stress_test.cc
View File

@ -34,21 +34,21 @@
#include <mutex>
#include <thread>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
#include <grpc++/create_channel.h>
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
#include <grpc++/server_context.h>
#include <grpc/grpc.h>
#include <grpc/support/thd.h>
#include <grpc/support/time.h>
#include <gtest/gtest.h>
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
#include "src/proto/grpc/testing/duplicate/echo_duplicate.grpc.pb.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
using grpc::testing::EchoRequest;
using grpc::testing::EchoResponse;
@ -74,7 +74,7 @@ void MaybeEchoDeadline(ServerContext* context, const EchoRequest* request,
} // namespace
class TestServiceImpl : public ::grpc::testing::TestService::Service {
class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
public:
TestServiceImpl() : signal_client_(false) {}
@ -159,7 +159,7 @@ class TestServiceImpl : public ::grpc::testing::TestService::Service {
};
class TestServiceImplDupPkg
: public ::grpc::testing::duplicate::TestService::Service {
: public ::grpc::testing::duplicate::EchoTestService::Service {
public:
Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE {
@ -191,10 +191,10 @@ class End2endTest : public ::testing::Test {
void ResetStub() {
std::shared_ptr<Channel> channel =
CreateChannel(server_address_.str(), InsecureChannelCredentials());
stub_ = grpc::testing::TestService::NewStub(channel);
stub_ = grpc::testing::EchoTestService::NewStub(channel);
}
std::unique_ptr<grpc::testing::TestService::Stub> stub_;
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<Server> server_;
std::ostringstream server_address_;
const int kMaxMessageSize_;
@ -202,7 +202,7 @@ class End2endTest : public ::testing::Test {
TestServiceImplDupPkg dup_pkg_service_;
};
static void SendRpc(grpc::testing::TestService::Stub* stub, int num_rpcs) {
static void SendRpc(grpc::testing::EchoTestService::Stub* stub, int num_rpcs) {
EchoRequest request;
EchoResponse response;
request.set_message("Hello");

15
test/cpp/end2end/zookeeper_test.cc
View File

@ -37,15 +37,15 @@
#include <grpc++/server.h>
#include <grpc++/server_builder.h>
#include <grpc++/server_context.h>
#include <gtest/gtest.h>
#include <grpc/grpc.h>
#include <grpc/grpc_zookeeper.h>
#include <gtest/gtest.h>
#include <zookeeper/zookeeper.h>
#include "test/core/util/test_config.h"
#include "test/core/util/port.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "src/core/support/env.h"
#include "src/proto/grpc/testing/echo.grpc.pb.h"
#include "test/core/util/port.h"
#include "test/core/util/test_config.h"
using grpc::testing::EchoRequest;
using grpc::testing::EchoResponse;
@ -53,7 +53,8 @@ using grpc::testing::EchoResponse;
namespace grpc {
namespace testing {
class ZookeeperTestServiceImpl : public ::grpc::testing::TestService::Service {
class ZookeeperTestServiceImpl
: public ::grpc::testing::EchoTestService::Service {
public:
Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE {
@ -157,7 +158,7 @@ class ZookeeperTest : public ::testing::Test {
void ResetStub() {
string target = "zookeeper://" + zookeeper_address_ + "/test";
channel_ = CreateChannel(target, InsecureChannelCredentials());
stub_ = grpc::testing::TestService::NewStub(channel_);
stub_ = grpc::testing::EchoTestService::NewStub(channel_);
}
string to_string(const int number) {
@ -167,7 +168,7 @@ class ZookeeperTest : public ::testing::Test {
}
std::shared_ptr<Channel> channel_;
std::unique_ptr<grpc::testing::TestService::Stub> stub_;
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<Server> server1_;
std::unique_ptr<Server> server2_;
ZookeeperTestServiceImpl service_;

8
test/cpp/util/cli_call.cc
View File

@ -35,13 +35,13 @@
#include <iostream>
#include <grpc/grpc.h>
#include <grpc/support/log.h>
#include <grpc/support/slice.h>
#include <grpc++/support/byte_buffer.h>
#include <grpc++/channel.h>
#include <grpc++/client_context.h>
#include <grpc++/generic/generic_stub.h>
#include <grpc++/support/byte_buffer.h>
#include <grpc/grpc.h>
#include <grpc/support/log.h>
#include <grpc/support/slice.h>
namespace grpc {
namespace testing {

8
test/cpp/util/cli_call_test.cc
View File

@ -53,7 +53,7 @@ using grpc::testing::EchoResponse;
namespace grpc {
namespace testing {
class TestServiceImpl : public ::grpc::testing::TestService::Service {
class TestServiceImpl : public ::grpc::testing::EchoTestService::Service {
public:
Status Echo(ServerContext* context, const EchoRequest* request,
EchoResponse* response) GRPC_OVERRIDE {
@ -91,11 +91,11 @@ class CliCallTest : public ::testing::Test {
void ResetStub() {
channel_ =
CreateChannel(server_address_.str(), InsecureChannelCredentials());
stub_ = grpc::testing::TestService::NewStub(channel_);
stub_ = grpc::testing::EchoTestService::NewStub(channel_);
}
std::shared_ptr<Channel> channel_;
std::unique_ptr<grpc::testing::TestService::Stub> stub_;
std::unique_ptr<grpc::testing::EchoTestService::Stub> stub_;
std::unique_ptr<Server> server_;
std::ostringstream server_address_;
TestServiceImpl service_;
@ -115,7 +115,7 @@ TEST_F(CliCallTest, SimpleRpc) {
EXPECT_EQ(response.message(), request.message());
EXPECT_TRUE(s.ok());
const grpc::string kMethod("/grpc.testing.TestService/Echo");
const grpc::string kMethod("/grpc.testing.EchoTestService/Echo");
grpc::string request_bin, response_bin, expected_response_bin;
EXPECT_TRUE(request.SerializeToString(&request_bin));
EXPECT_TRUE(response.SerializeToString(&expected_response_bin));