Add a GetSignature() method to dbus::MessageReader.

dbus/message_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/message.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/posix/eintr_wrapper.h"
 #include "dbus/object_path.h"
 #include "dbus/test_proto.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace dbus {
 
 // Test that a byte can be properly written and read. We only have this
 // test for byte, as repeating this for other basic types is too redundant.
 TEST(MessageTest, AppendAndPopByte) {
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
   writer.AppendByte(123);  // The input is 123.
 
   MessageReader reader(message.get());
   ASSERT_TRUE(reader.HasMoreData());  // Should have data to read.
   ASSERT_EQ(Message::BYTE, reader.GetDataType());
+  ASSERT_EQ("y", reader.GetDataSignature());
 
   bool bool_value = false;
   // Should fail as the type is not bool here.
   ASSERT_FALSE(reader.PopBool(&bool_value));
 
   uint8 byte_value = 0;
   ASSERT_TRUE(reader.PopByte(&byte_value));
   EXPECT_EQ(123, byte_value);  // Should match with the input.
   ASSERT_FALSE(reader.HasMoreData());  // Should not have more data to read.
 
@@ skipping 26 matching lines @@
   int32 int32_value = 0;
   uint32 uint32_value = 0;
   int64 int64_value = 0;
   uint64 uint64_value = 0;
   double double_value = 0;
   std::string string_value;
   ObjectPath object_path_value;
 
   MessageReader reader(message.get());
   ASSERT_TRUE(reader.HasMoreData());
+  ASSERT_EQ("y", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopByte(&byte_value));
+  ASSERT_EQ("b", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopBool(&bool_value));
+  ASSERT_EQ("n", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopInt16(&int16_value));
+  ASSERT_EQ("q", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopUint16(&uint16_value));
+  ASSERT_EQ("i", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopInt32(&int32_value));
+  ASSERT_EQ("u", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopUint32(&uint32_value));
+  ASSERT_EQ("x", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopInt64(&int64_value));
+  ASSERT_EQ("t", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopUint64(&uint64_value));
+  ASSERT_EQ("d", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopDouble(&double_value));
+  ASSERT_EQ("s", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopString(&string_value));
+  ASSERT_EQ("o", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopObjectPath(&object_path_value));
+  ASSERT_EQ("", reader.GetDataSignature());
   ASSERT_FALSE(reader.HasMoreData());
 
   // 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path" should be returned.
   EXPECT_EQ(0, byte_value);
   EXPECT_EQ(true, bool_value);
   EXPECT_EQ(2, int16_value);
   EXPECT_EQ(3U, uint16_value);
   EXPECT_EQ(4, int32_value);
   EXPECT_EQ(5U, uint32_value);
   EXPECT_EQ(6, int64_value);
@@ skipping 19 matching lines @@
   ASSERT_FALSE(temp.is_valid());
   // NB: thread IO requirements not relevant for unit tests.
   temp.CheckValidity();
   ASSERT_TRUE(temp.is_valid());
   writer.AppendFileDescriptor(temp);
 
   FileDescriptor fd_value;
 
   MessageReader reader(message.get());
   ASSERT_TRUE(reader.HasMoreData());
+  ASSERT_EQ(Message::UNIX_FD, reader.GetDataType());
+  ASSERT_EQ("h", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopFileDescriptor(&fd_value));
   ASSERT_FALSE(reader.HasMoreData());
   // Descriptor is not valid until explicitly checked.
   ASSERT_FALSE(fd_value.is_valid());
   fd_value.CheckValidity();
   ASSERT_TRUE(fd_value.is_valid());
 
   // Stdout should be returned but we cannot check the descriptor
   // value because stdout will be dup'd.  Instead check st_rdev
   // which should be identical.
@@ skipping 31 matching lines @@
   int32 int32_value = 0;
   uint32 uint32_value = 0;
   int64 int64_value = 0;
   uint64 uint64_value = 0;
   double double_value = 0;
   std::string string_value;
   ObjectPath object_path_value;
 
   MessageReader reader(message.get());
   ASSERT_TRUE(reader.HasMoreData());
   ASSERT_TRUE(reader.PopVariantOfByte(&byte_value));

[satorux1, 2014/08/25 05:33:27]

maybe add tests for reader.GetDataSignature() in this function for the sake of
completeness?

[Ben Chan, 2014/08/25 05:43:08]

Done.

   ASSERT_TRUE(reader.PopVariantOfBool(&bool_value));
   ASSERT_TRUE(reader.PopVariantOfInt16(&int16_value));
   ASSERT_TRUE(reader.PopVariantOfUint16(&uint16_value));
   ASSERT_TRUE(reader.PopVariantOfInt32(&int32_value));
   ASSERT_TRUE(reader.PopVariantOfUint32(&uint32_value));
   ASSERT_TRUE(reader.PopVariantOfInt64(&int64_value));
   ASSERT_TRUE(reader.PopVariantOfUint64(&uint64_value));
   ASSERT_TRUE(reader.PopVariantOfDouble(&double_value));
   ASSERT_TRUE(reader.PopVariantOfString(&string_value));
   ASSERT_TRUE(reader.PopVariantOfObjectPath(&object_path_value));
@@ skipping 18 matching lines @@
   MessageWriter writer(message.get());
   std::vector<uint8> bytes;
   bytes.push_back(1);
   bytes.push_back(2);
   bytes.push_back(3);
   writer.AppendArrayOfBytes(bytes.data(), bytes.size());
 
   MessageReader reader(message.get());
   const uint8* output_bytes = NULL;
   size_t length = 0;
+  ASSERT_EQ("ay", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length));
   ASSERT_FALSE(reader.HasMoreData());
   ASSERT_EQ(3U, length);
   EXPECT_EQ(1, output_bytes[0]);
   EXPECT_EQ(2, output_bytes[1]);
   EXPECT_EQ(3, output_bytes[2]);
 }
 
 TEST(MessageTest, ArrayOfBytes_Empty) {
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
   std::vector<uint8> bytes;
   writer.AppendArrayOfBytes(bytes.data(), bytes.size());
 
   MessageReader reader(message.get());
   const uint8* output_bytes = NULL;
   size_t length = 0;
+  ASSERT_EQ("ay", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopArrayOfBytes(&output_bytes, &length));
   ASSERT_FALSE(reader.HasMoreData());
   ASSERT_EQ(0U, length);
   EXPECT_EQ(NULL, output_bytes);
 }
 
 TEST(MessageTest, ArrayOfStrings) {
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
   std::vector<std::string> strings;
   strings.push_back("fee");
   strings.push_back("fie");
   strings.push_back("foe");
   strings.push_back("fum");
   writer.AppendArrayOfStrings(strings);
 
   MessageReader reader(message.get());
   std::vector<std::string> output_strings;
+  ASSERT_EQ("as", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopArrayOfStrings(&output_strings));
   ASSERT_FALSE(reader.HasMoreData());
   ASSERT_EQ(4U, output_strings.size());
   EXPECT_EQ("fee", output_strings[0]);
   EXPECT_EQ("fie", output_strings[1]);
   EXPECT_EQ("foe", output_strings[2]);
   EXPECT_EQ("fum", output_strings[3]);
 }
 
 TEST(MessageTest, ArrayOfObjectPaths) {
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
   std::vector<ObjectPath> object_paths;
   object_paths.push_back(ObjectPath("/object/path/1"));
   object_paths.push_back(ObjectPath("/object/path/2"));
   object_paths.push_back(ObjectPath("/object/path/3"));
   writer.AppendArrayOfObjectPaths(object_paths);
 
   MessageReader reader(message.get());
   std::vector<ObjectPath> output_object_paths;
+  ASSERT_EQ("ao", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopArrayOfObjectPaths(&output_object_paths));
   ASSERT_FALSE(reader.HasMoreData());
   ASSERT_EQ(3U, output_object_paths.size());
   EXPECT_EQ(ObjectPath("/object/path/1"), output_object_paths[0]);
   EXPECT_EQ(ObjectPath("/object/path/2"), output_object_paths[1]);
   EXPECT_EQ(ObjectPath("/object/path/3"), output_object_paths[2]);
 }
 
 TEST(MessageTest, ProtoBuf) {
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
   TestProto send_message;
   send_message.set_text("testing");
   send_message.set_number(123);
   writer.AppendProtoAsArrayOfBytes(send_message);
 
   MessageReader reader(message.get());

[satorux1, 2014/08/25 05:33:27]

ditto. maybe add a test for reader.GetDataSignature() for completeness?

[Ben Chan, 2014/08/25 05:43:08]

Done.

   TestProto receive_message;
   ASSERT_TRUE(reader.PopArrayOfBytesAsProto(&receive_message));
   EXPECT_EQ(receive_message.text(), send_message.text());
   EXPECT_EQ(receive_message.number(), send_message.number());
 }
 
 
 // Test that an array can be properly written and read. We only have this
 // test for array, as repeating this for other container types is too
 // redundant.
 TEST(MessageTest, OpenArrayAndPopArray) {
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
   MessageWriter array_writer(NULL);
   writer.OpenArray("s", &array_writer);  // Open an array of strings.
   array_writer.AppendString("foo");
   array_writer.AppendString("bar");
   array_writer.AppendString("baz");
   writer.CloseContainer(&array_writer);
 
   MessageReader reader(message.get());
   ASSERT_EQ(Message::ARRAY, reader.GetDataType());
+  ASSERT_EQ("as", reader.GetDataSignature());
   MessageReader array_reader(NULL);
   ASSERT_TRUE(reader.PopArray(&array_reader));
   ASSERT_FALSE(reader.HasMoreData());  // Should not have more data to read.
 
   std::string string_value;
   ASSERT_TRUE(array_reader.PopString(&string_value));
   EXPECT_EQ("foo", string_value);
   ASSERT_TRUE(array_reader.PopString(&string_value));
   EXPECT_EQ("bar", string_value);
   ASSERT_TRUE(array_reader.PopString(&string_value));
@@ skipping 73 matching lines @@
             "  variant     array [\n"
             "      dict entry {\n"
             "        string \"foo\"\n"
             "        int64 1234567890123456789\n"
             "      }\n"
             "    ]\n"
             "]\n",
             message->ToString());
 
   MessageReader reader(message.get());
+  ASSERT_EQ("av", reader.GetDataSignature());
   MessageReader array_reader(NULL);
   ASSERT_TRUE(reader.PopArray(&array_reader));
 
   // The first value in the array.
   bool bool_value = false;
+  ASSERT_EQ("v", array_reader.GetDataSignature());
   ASSERT_TRUE(array_reader.PopVariantOfBool(&bool_value));
   EXPECT_EQ(true, bool_value);
 
   // The second value in the array.
   {
     MessageReader variant_reader(NULL);
     ASSERT_TRUE(array_reader.PopVariant(&variant_reader));
     {
       MessageReader struct_reader(NULL);
+      ASSERT_EQ("(si)", variant_reader.GetDataSignature());
       ASSERT_TRUE(variant_reader.PopStruct(&struct_reader));
       std::string string_value;
       ASSERT_TRUE(struct_reader.PopString(&string_value));
       EXPECT_EQ("string", string_value);
       int32 int32_value = 0;
       ASSERT_TRUE(struct_reader.PopInt32(&int32_value));
       EXPECT_EQ(123, int32_value);
       ASSERT_FALSE(struct_reader.HasMoreData());
     }
     ASSERT_FALSE(variant_reader.HasMoreData());
   }
 
   // The third value in the array.
   {
     MessageReader variant_reader(NULL);
     ASSERT_TRUE(array_reader.PopVariant(&variant_reader));
     {
       MessageReader dict_array_reader(NULL);
+      ASSERT_EQ("a{sx}", variant_reader.GetDataSignature());
       ASSERT_TRUE(variant_reader.PopArray(&dict_array_reader));
       {
         MessageReader dict_entry_reader(NULL);
         ASSERT_TRUE(dict_array_reader.PopDictEntry(&dict_entry_reader));
         std::string string_value;
         ASSERT_TRUE(dict_entry_reader.PopString(&string_value));
         EXPECT_EQ("foo", string_value);
         int64 int64_value = 0;
         ASSERT_TRUE(dict_entry_reader.PopInt64(&int64_value));
         EXPECT_EQ(GG_INT64_C(1234567890123456789), int64_value);
@@ skipping 181 matching lines @@
 
   ASSERT_EQ("message_type: MESSAGE_METHOD_RETURN\n"
             "signature: s\n\n"
             "string \"oooooooooooooooooooooooooooooooooooooooooooooooo"
             "oooooooooooooooooooooooooooooooooooooooooooooooooooo... "
             "(1000 bytes in total)\"\n",
             message->ToString());
 }
 
 }  // namespace dbus