Enhance the DBus interface for peerd

dbus/property_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 "dbus/property.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 17 matching lines @@
  public:
   PropertyTest() {
   }
 
   struct Properties : public PropertySet {
     Property<std::string> name;
     Property<int16> version;
     Property<std::vector<std::string> > methods;
     Property<std::vector<ObjectPath> > objects;
     Property<std::vector<uint8> > bytes;
+    Property<std::map<std::string, std::string>> string_map;
+    Property<std::vector<std::pair<std::vector<uint8>, uint16>>> ip_port_list;
 
     Properties(ObjectProxy* object_proxy,
                PropertyChangedCallback property_changed_callback)
         : PropertySet(object_proxy,
                       "org.chromium.TestInterface",
                       property_changed_callback) {
       RegisterProperty("Name", &name);
       RegisterProperty("Version", &version);
       RegisterProperty("Methods", &methods);
       RegisterProperty("Objects", &objects);
       RegisterProperty("Bytes", &bytes);
+      RegisterProperty("StringMap", &string_map);
+      RegisterProperty("IPList", &ip_port_list);
     }
   };
 
   void SetUp() override {
     // Make the main thread not to allow IO.
     base::ThreadRestrictions::SetIOAllowed(false);
 
     // Start the D-Bus thread.
     dbus_thread_.reset(new base::Thread("D-Bus Thread"));
     base::Thread::Options thread_options;
@@ skipping 61 matching lines @@
   void WaitForUpdates(size_t num_updates) {
     while (updated_properties_.size() < num_updates) {
       run_loop_.reset(new base::RunLoop);
       run_loop_->Run();
     }
     for (size_t i = 0; i < num_updates; ++i)
       updated_properties_.erase(updated_properties_.begin());
   }
 
   // Name, Version, Methods, Objects
-  static const int kExpectedSignalUpdates = 5;
+  static const int kExpectedSignalUpdates = 7;
 
   // Waits for initial values to be set.
   void WaitForGetAll() {
     WaitForUpdates(kExpectedSignalUpdates);
   }
 
   // Waits for the callback. |id| is the string bound to the callback when
   // the method call is made that identifies it and distinguishes from any
   // other; you can set this to whatever you wish.
   void WaitForCallback(const std::string& id) {
@@ skipping 32 matching lines @@
   std::vector<ObjectPath> objects = properties_->objects.value();
   ASSERT_EQ(1U, objects.size());
   EXPECT_EQ(ObjectPath("/TestObjectPath"), objects[0]);
 
   std::vector<uint8> bytes = properties_->bytes.value();
   ASSERT_EQ(4U, bytes.size());
   EXPECT_EQ('T', bytes[0]);
   EXPECT_EQ('e', bytes[1]);
   EXPECT_EQ('s', bytes[2]);
   EXPECT_EQ('t', bytes[3]);
+
+  std::map<std::string, std::string> string_map =
+      properties_->string_map.value();
+  ASSERT_EQ(4U, string_map.size());
+  EXPECT_EQ("1", string_map["One"]);
+  EXPECT_EQ("2", string_map["Two"]);
+  EXPECT_EQ("3", string_map["Three"]);
+  EXPECT_EQ("4", string_map["Four"]);
+
+  std::vector<std::pair<std::vector<uint8>, uint16>> ip_list =
+      properties_->ip_port_list.value();
+  ASSERT_EQ(5U, ip_list.size());
+  for (size_t i = 0; i < ip_list.size(); ++i) {
+    EXPECT_EQ(5U, ip_list[i].first.size());
+    EXPECT_EQ('T', ip_list[i].first[0]);
+    EXPECT_EQ('e', ip_list[i].first[1]);
+    EXPECT_EQ('s', ip_list[i].first[2]);
+    EXPECT_EQ('t', ip_list[i].first[3]);
+    EXPECT_EQ('0' + i, ip_list[i].first[4]);
+    EXPECT_EQ(i, ip_list[i].second);
+  }
 }
 
 TEST_F(PropertyTest, UpdatedValues) {
   WaitForGetAll();
 
   // Update the value of the "Name" property, this value should not change.
   properties_->name.Get(base::Bind(&PropertyTest::PropertyCallback,
                                    base::Unretained(this),
                                    "Name"));
   WaitForCallback("Name");
@@ skipping 44 matching lines @@
                                    "Bytes"));
   WaitForCallback("Bytes");
   WaitForUpdates(1);
 
   std::vector<uint8> bytes = properties_->bytes.value();
   ASSERT_EQ(4U, bytes.size());
   EXPECT_EQ('T', bytes[0]);
   EXPECT_EQ('e', bytes[1]);
   EXPECT_EQ('s', bytes[2]);
   EXPECT_EQ('t', bytes[3]);
+
+  // Update the value of the "Bytes" property, this value should not change
+  // and should not grow to contain duplicate entries.
+  properties_->bytes.Get(base::Bind(&PropertyTest::PropertyCallback,
+                                    base::Unretained(this), "StringMap"));
+  WaitForCallback("StringMap");
+  WaitForUpdates(1);
+
+  std::map<std::string, std::string> string_map =
+      properties_->string_map.value();
+  ASSERT_EQ(4U, string_map.size());
+  EXPECT_EQ("1", string_map["One"]);
+  EXPECT_EQ("2", string_map["Two"]);
+  EXPECT_EQ("3", string_map["Three"]);
+  EXPECT_EQ("4", string_map["Four"]);
+
+  // Update the value of the "Bytes" property, this value should not change
+  // and should not grow to contain duplicate entries.
+  properties_->bytes.Get(base::Bind(&PropertyTest::PropertyCallback,
+                                    base::Unretained(this), "IPList"));
+  WaitForCallback("IPList");
+  WaitForUpdates(1);
+
+  std::vector<std::pair<std::vector<uint8>, uint16>> ip_list =
+      properties_->ip_port_list.value();
+  ASSERT_EQ(5U, ip_list.size());
+  for (size_t i = 0; i < ip_list.size(); ++i) {
+    EXPECT_EQ(5U, ip_list[i].first.size());
+    EXPECT_EQ('T', ip_list[i].first[0]);
+    EXPECT_EQ('e', ip_list[i].first[1]);
+    EXPECT_EQ('s', ip_list[i].first[2]);
+    EXPECT_EQ('t', ip_list[i].first[3]);
+    EXPECT_EQ('0' + i, ip_list[i].first[4]);
+    EXPECT_EQ(i, ip_list[i].second);
+  }

[hashimoto, 2015/02/06 07:45:12]

Instead of changing test_service.cc, how about adding simpler test cases like:

  // Construct message.
  dbus::Message message;
  MessageWriter write(&message));
  ...
  MessageReader reader(&message);
  
  Property<std::map<std::string, std::string>> property;
  EXPECT_TRUE(property.PopValueFromReader(&reader));
  
  // Verify the result.
  ...

You can add a setter for set_value to test AppendSetValueToWriter().
FYI: By including strings like "ForTesting" in the setter function name, you can
prevent improper usage in code other than tests.
https://cs.chromium.org/file:src/PRESUBMIT.py%20ForTest

[dtapuska, 2015/02/06 15:56:01]

Done.

 }
 
 TEST_F(PropertyTest, Get) {
   WaitForGetAll();
 
   // Ask for the new Version property.
   properties_->version.Get(base::Bind(&PropertyTest::PropertyCallback,
                                       base::Unretained(this),
                                       "Get"));
   WaitForCallback("Get");
@@ skipping 14 matching lines @@
                                    "Set"));
   WaitForCallback("Set");
 
   // TestService sends a property update.
   WaitForUpdates(1);
 
   EXPECT_EQ("NewService", properties_->name.value());
 }
 
 }  // namespace dbus