Restart of ceee_broker on crash.

ceee/ie/broker/broker_rpc_unittest.cc

Index: ceee/ie/broker/broker_rpc_unittest.cc
===================================================================
--- ceee/ie/broker/broker_rpc_unittest.cc	(revision 67655)
+++ ceee/ie/broker/broker_rpc_unittest.cc	(working copy)
@@ -24,12 +24,12 @@
 
 MOCK_STATIC_CLASS_BEGIN(BrokerRpcMock)
   MOCK_STATIC_INIT_BEGIN(BrokerRpcMock)
-    MOCK_STATIC_INIT(GetRpcEndPointAddress);
+    MOCK_STATIC_INIT(GetRpcEndpointAddress);
     MOCK_STATIC_INIT(BrokerRpcServer_FireEvent);
     MOCK_STATIC_INIT(BrokerRpcServer_SendUmaHistogramTimes);
     MOCK_STATIC_INIT(BrokerRpcServer_SendUmaHistogramData);
   MOCK_STATIC_INIT_END()
-  MOCK_STATIC0(std::wstring, , GetRpcEndPointAddress);
+  MOCK_STATIC0(std::wstring, , GetRpcEndpointAddress);
   MOCK_STATIC3(void, , BrokerRpcServer_FireEvent, handle_t, const char*,
                const char*);
   MOCK_STATIC3(void, , BrokerRpcServer_SendUmaHistogramTimes, handle_t,
@@ -41,7 +41,7 @@
 class BrokerRpcTest : public testing::Test {
  protected:
   virtual void SetUp() {
-    EXPECT_CALL(broker_rpc_mock_, GetRpcEndPointAddress())
+    EXPECT_CALL(broker_rpc_mock_, GetRpcEndpointAddress())
         .WillRepeatedly(Return(L"BrokerRpcTestEP"));
   }
 
@@ -52,7 +52,7 @@
 };
 
 TEST_F(BrokerRpcTest, ConnectNoServer) {
-  BrokerRpcClient client;
+  BrokerRpcClient client(false);
   ASSERT_FALSE(client.is_connected());
   ASSERT_HRESULT_FAILED(client.Connect(false));
   ASSERT_FALSE(client.is_connected());
@@ -63,7 +63,7 @@
   ASSERT_FALSE(server.is_started());
   ASSERT_TRUE(server.Start());
   ASSERT_TRUE(server.is_started());
-  BrokerRpcClient client;
+  BrokerRpcClient client(false);
   ASSERT_HRESULT_SUCCEEDED(client.Connect(false));
   ASSERT_TRUE(client.is_connected());
 }
@@ -72,7 +72,7 @@
   BrokerRpcServer server;
   ASSERT_TRUE(server.Start());
 
-  BrokerRpcClient client;
+  BrokerRpcClient client(false);
   ASSERT_HRESULT_SUCCEEDED(client.Connect(false));
 
   const char* name = "name";
@@ -95,4 +95,69 @@
   ASSERT_HRESULT_SUCCEEDED(client.SendUmaHistogramData(name, 1, 2, 3, 4));
 }
 
+class BrokerRpcClientMock : public BrokerRpcClient {
+ public:
+  explicit BrokerRpcClientMock(bool allow_restarts)
+      : BrokerRpcClient(allow_restarts) {}
+  MOCK_METHOD0(StartServerMock, HRESULT());
+ protected:
+  HRESULT StartServer(IUnknown** server) {
+    server_.Start();
+    return StartServerMock();
+  }
+
+ public:
+  BrokerRpcServer server_;
+};
+
+TEST_F(BrokerRpcTest, StartServer) {
+  BrokerRpcClientMock client(true);
+  EXPECT_CALL(client, StartServerMock())
+      .Times(0);
+  ASSERT_HRESULT_FAILED(client.Connect(false));
+
+  EXPECT_CALL(client, StartServerMock())
+      .Times(1)
+      .WillOnce(Return(RPC_E_FAULT));
+  ASSERT_HRESULT_FAILED(client.Connect(true));
+
+  EXPECT_CALL(client, StartServerMock())
+      .Times(1)
+      .WillOnce(Return(S_OK));
+  ASSERT_HRESULT_SUCCEEDED(client.Connect(true));
+}
+
+TEST_F(BrokerRpcTest, NoRestartServer) {
+  BrokerRpcClientMock client(false);
+  EXPECT_CALL(client, StartServerMock())
+      .Times(1)
+      .WillOnce(Return(S_OK));
+  ASSERT_HRESULT_SUCCEEDED(client.Connect(true));
+  client.server_.Stop();
+
+  EXPECT_CALL(client, StartServerMock())
+      .Times(0);
+  EXPECT_CALL(broker_rpc_mock_,
+      BrokerRpcServer_FireEvent(_, _, _))
+          .Times(0);
+  ASSERT_HRESULT_FAILED(client.FireEvent("A", "B"));
+}
+
+TEST_F(BrokerRpcTest, RestartServer) {
+  BrokerRpcClientMock client(true);
+  EXPECT_CALL(client, StartServerMock())
+      .Times(1)
+      .WillOnce(Return(S_OK));
+  ASSERT_HRESULT_SUCCEEDED(client.Connect(true));
+  client.server_.Stop();
+
+  EXPECT_CALL(client, StartServerMock())
+      .Times(1)
+      .WillOnce(Return(S_OK));
+  EXPECT_CALL(broker_rpc_mock_,
+      BrokerRpcServer_FireEvent(_, _, _))
+          .Times(1);
+  ASSERT_HRESULT_SUCCEEDED(client.FireEvent("A", "B"));
+}
+
 }  // namespace