Firing event to broker without worker thread.

ceee/ie/broker/broker_rpc_unittest.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ceee/ie/broker/broker_rpc_client.h"
 #include "ceee/ie/broker/broker_rpc_server.h"
 
 #include <atlbase.h>
 #include "broker_rpc_lib.h"  // NOLINT
 #include "ceee/ie/broker/broker_rpc_utils.h"
@@ skipping 10 matching lines @@
 namespace {
 
 using testing::_;
 
 MOCK_STATIC_CLASS_BEGIN(BrokerRpcMock)
   MOCK_STATIC_INIT_BEGIN(BrokerRpcMock)
     MOCK_STATIC_INIT(GetRpcEndPointAddress);
     MOCK_STATIC_INIT(BrokerRpcServer_FireEvent)
   MOCK_STATIC_INIT_END()
   MOCK_STATIC0(std::wstring, , GetRpcEndPointAddress);
-  MOCK_STATIC3(void, , BrokerRpcServer_FireEvent, handle_t, BSTR, BSTR);
+  MOCK_STATIC3(void, , BrokerRpcServer_FireEvent, handle_t, const char*,
+               const char*);
 MOCK_STATIC_CLASS_END(BrokerRpcMock)
 
 class BrokerRpcTest : public testing::Test {
  protected:
   virtual void SetUp() {
     EXPECT_CALL(broker_rpc_mock_, GetRpcEndPointAddress())
         .WillRepeatedly(Return(L"BrokerRpcTestEP"));
   }
 
   virtual void TearDown() {
   }
 
   BrokerRpcMock broker_rpc_mock_;
 };
 
 TEST_F(BrokerRpcTest, ConnectNoServer) {
   BrokerRpcClient client;
   ASSERT_FALSE(client.is_connected());
-  ASSERT_FALSE(client.Connect());
+  ASSERT_FALSE(SUCCEEDED(client.Connect()));
   ASSERT_FALSE(client.is_connected());
 }
 
 TEST_F(BrokerRpcTest, Connect) {
   BrokerRpcServer server;
   ASSERT_FALSE(server.is_started());
   ASSERT_TRUE(server.Start());
   ASSERT_TRUE(server.is_started());
   BrokerRpcClient client;
-  ASSERT_TRUE(client.Connect());
+  ASSERT_TRUE(SUCCEEDED(client.Connect()));
   ASSERT_TRUE(client.is_connected());
 }
 
 TEST_F(BrokerRpcTest, FireEvent) {
   BrokerRpcServer server;
   ASSERT_TRUE(server.Start());
 
   BrokerRpcClient client;
-  ASSERT_TRUE(client.Connect());
+  ASSERT_TRUE(SUCCEEDED(client.Connect()));
 
-  CComBSTR event_name = L"event_name";
-  CComBSTR event_args = L"event_args";
+  const char* event_name = "event_name";
+  const char* event_args = "event_args";
 
-  EXPECT_CALL(broker_rpc_mock_, BrokerRpcServer_FireEvent(_,
-      StrEq(event_name.m_str), StrEq(event_args.m_str)))
-          .Times(1);
+  EXPECT_CALL(broker_rpc_mock_, BrokerRpcServer_FireEvent(_, StrEq(event_name),
+                                                          StrEq(event_args)))
+      .Times(1);
 
-  ASSERT_TRUE(client.FireEvent(event_name, event_args));
+  ASSERT_TRUE(SUCCEEDED(client.FireEvent(event_name, event_args)));
 }
 
 }  // namespace