Pull out common code from client and host versions of ServerLogEntry.

remoting/host/server_log_entry_host_unittest.cc

 // Copyright (c) 2012 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 "base/memory/scoped_ptr.h"
 #include "base/strings/stringize_macros.h"
-#include "remoting/host/server_log_entry.h"
+#include "remoting/host/server_log_entry_host.h"
+#include "remoting/protocol/server_log_entry.h"
+#include "remoting/protocol/server_log_entry_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libjingle/source/talk/xmllite/xmlelement.h"
 
 using buzz::XmlAttr;
 using buzz::XmlElement;
+using remoting::protocol::ServerLogEntry;
+using remoting::protocol::VerifyStanza;
 
 namespace remoting {
 
-class ServerLogEntryTest : public testing::Test {
- protected:
-  // Verifies a logging stanza.
-  // |keyValuePairs| lists the keys that must have specified values, and |keys|
-  // lists the keys that must be present, but may have arbitrary values.
-  // There must be no other keys.
-  static bool VerifyStanza(
-      const std::map<std::string, std::string>& key_value_pairs,
-      const std::set<std::string> keys,
-      const XmlElement* elem,
-      std::string* error) {
-    int attrCount = 0;
-    for (const XmlAttr* attr = elem->FirstAttr(); attr != NULL;
-         attr = attr->NextAttr(), attrCount++) {
-      if (attr->Name().Namespace().length() != 0) {
-        *error = "attribute has non-empty namespace " +
-            attr->Name().Namespace();
-        return false;
-      }
-      const std::string& key = attr->Name().LocalPart();
-      const std::string& value = attr->Value();
-      std::map<std::string, std::string>::const_iterator iter =
-          key_value_pairs.find(key);
-      if (iter == key_value_pairs.end()) {
-        if (keys.find(key) == keys.end()) {
-          *error = "unexpected attribute " + key;
-          return false;
-        }
-      } else {
-        if (iter->second != value) {
-          *error = "attribute " + key + " has value " + iter->second +
-              ": expected " + value;
-          return false;
-        }
-      }
-    }
-    int attr_count_expected = key_value_pairs.size() + keys.size();
-    if (attrCount != attr_count_expected) {
-      std::stringstream s;
-      s << "stanza has " << attrCount << " keys: expected "
-        << attr_count_expected;
-      *error = s.str();
-      return false;
-    }
-    return true;
-  }
-};
-
-TEST_F(ServerLogEntryTest, MakeForSessionStateChange) {
-  scoped_ptr<ServerLogEntry> entry(
-      ServerLogEntry::MakeForSessionStateChange(true));
+TEST(ServerLogEntryHostTest, MakeForSessionStateChange) {
+  scoped_ptr<ServerLogEntry> entry(MakeLogEntryForSessionStateChange(true));
   scoped_ptr<XmlElement> stanza = entry->ToStanza();
   std::string error;
   std::map<std::string, std::string> key_value_pairs;
   key_value_pairs["role"] = "host";
   key_value_pairs["event-name"] = "session-state";
   key_value_pairs["session-state"] = "connected";
   std::set<std::string> keys;
   ASSERT_TRUE(VerifyStanza(key_value_pairs, keys, stanza.get(), &error))
       << error;
 }
 
-TEST_F(ServerLogEntryTest, MakeForHeartbeat) {
-  scoped_ptr<ServerLogEntry> entry(ServerLogEntry::MakeForHeartbeat());
+TEST(ServerLogEntryHostTest, MakeForHeartbeat) {
+  scoped_ptr<ServerLogEntry> entry(MakeLogEntryForHeartbeat());
   scoped_ptr<XmlElement> stanza = entry->ToStanza();
   std::string error;
   std::map<std::string, std::string> key_value_pairs;
   key_value_pairs["role"] = "host";
   key_value_pairs["event-name"] = "heartbeat";
   std::set<std::string> keys;
   ASSERT_TRUE(VerifyStanza(key_value_pairs, keys, stanza.get(), &error))
       << error;
 }
 
-TEST_F(ServerLogEntryTest, AddHostFields) {
-  scoped_ptr<ServerLogEntry> entry(
-      ServerLogEntry::MakeForSessionStateChange(true));
-  entry->AddHostFields();
+TEST(ServerLogEntryHostTest, AddHostFields) {
+  scoped_ptr<ServerLogEntry> entry(MakeLogEntryForSessionStateChange(true));
+  AddHostFieldsToLogEntry(entry.get());
   scoped_ptr<XmlElement> stanza = entry->ToStanza();
   std::string error;
   std::map<std::string, std::string> key_value_pairs;
   key_value_pairs["role"] = "host";
   key_value_pairs["event-name"] = "session-state";
   key_value_pairs["session-state"] = "connected";
   std::set<std::string> keys;
   keys.insert("cpu");
 #if defined(OS_WIN)
   key_value_pairs["os-name"] = "Windows";
   keys.insert("os-version");
 #elif defined(OS_MACOSX)
   key_value_pairs["os-name"] = "Mac";
   keys.insert("os-version");
 #elif defined(OS_CHROMEOS)
   key_value_pairs["os-name"] = "ChromeOS";
   keys.insert("os-version");
 #elif defined(OS_LINUX)
   key_value_pairs["os-name"] = "Linux";
 #endif
   key_value_pairs["host-version"] = STRINGIZE(VERSION);
   ASSERT_TRUE(VerifyStanza(key_value_pairs, keys, stanza.get(), &error)) <<
       error;
 }
 
-TEST_F(ServerLogEntryTest, AddModeField1) {
-  scoped_ptr<ServerLogEntry> entry(
-      ServerLogEntry::MakeForSessionStateChange(true));
+TEST(ServerLogEntryHostTest, AddModeField1) {
+  scoped_ptr<ServerLogEntry> entry(MakeLogEntryForSessionStateChange(true));
   entry->AddModeField(ServerLogEntry::IT2ME);
   scoped_ptr<XmlElement> stanza = entry->ToStanza();
   std::string error;
   std::map<std::string, std::string> key_value_pairs;
   key_value_pairs["role"] = "host";
   key_value_pairs["event-name"] = "session-state";
   key_value_pairs["session-state"] = "connected";
   key_value_pairs["mode"] = "it2me";
   std::set<std::string> keys;
   ASSERT_TRUE(VerifyStanza(key_value_pairs, keys, stanza.get(), &error)) <<
       error;
 }
 
-TEST_F(ServerLogEntryTest, AddModeField2) {
-  scoped_ptr<ServerLogEntry> entry(
-      ServerLogEntry::MakeForSessionStateChange(true));
+TEST(ServerLogEntryHostTest, AddModeField2) {
+  scoped_ptr<ServerLogEntry> entry(MakeLogEntryForSessionStateChange(true));
   entry->AddModeField(ServerLogEntry::ME2ME);
   scoped_ptr<XmlElement> stanza = entry->ToStanza();
   std::string error;
   std::map<std::string, std::string> key_value_pairs;
   key_value_pairs["role"] = "host";
   key_value_pairs["event-name"] = "session-state";
   key_value_pairs["session-state"] = "connected";
   key_value_pairs["mode"] = "me2me";
   std::set<std::string> keys;
   ASSERT_TRUE(VerifyStanza(key_value_pairs, keys, stanza.get(), &error)) <<
       error;
 }
 
 }  // namespace remoting