Switch to standard integer types in dbus/.

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 <stddef.h>
 #include <stdint.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;
+  uint8_t 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.
 
   // Try to get another byte. Should fail.
   ASSERT_FALSE(reader.PopByte(&byte_value));
 }
 
 // Check all basic types can be properly written and read.
 TEST(MessageTest, AppendAndPopBasicDataTypes) {
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
 
   // Append 0, 1, 2, 3, 4, 5, 6, 7, 8, "string", "/object/path".
   writer.AppendByte(0);
   writer.AppendBool(true);
   writer.AppendInt16(2);
   writer.AppendUint16(3);
   writer.AppendInt32(4);
   writer.AppendUint32(5);
   writer.AppendInt64(6);
   writer.AppendUint64(7);
   writer.AppendDouble(8.0);
   writer.AppendString("string");
   writer.AppendObjectPath(ObjectPath("/object/path"));
 
-  uint8 byte_value = 0;
+  uint8_t byte_value = 0;
   bool bool_value = false;
-  int16 int16_value = 0;
-  uint16 uint16_value = 0;
-  int32 int32_value = 0;
-  uint32 uint32_value = 0;
-  int64 int64_value = 0;
-  uint64 uint64_value = 0;
+  int16_t int16_value = 0;
+  uint16_t uint16_value = 0;
+  int32_t int32_value = 0;
+  uint32_t uint32_value = 0;
+  int64_t int64_value = 0;
+  uint64_t 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));
@@ skipping 87 matching lines @@
   writer.AppendVariantOfInt16(2);
   writer.AppendVariantOfUint16(3);
   writer.AppendVariantOfInt32(4);
   writer.AppendVariantOfUint32(5);
   writer.AppendVariantOfInt64(6);
   writer.AppendVariantOfUint64(7);
   writer.AppendVariantOfDouble(8.0);
   writer.AppendVariantOfString("string");
   writer.AppendVariantOfObjectPath(ObjectPath("/object/path"));
 
-  uint8 byte_value = 0;
+  uint8_t byte_value = 0;
   bool bool_value = false;
-  int16 int16_value = 0;
-  uint16 uint16_value = 0;
-  int32 int32_value = 0;
-  uint32 uint32_value = 0;
-  int64 int64_value = 0;
-  uint64 uint64_value = 0;
+  int16_t int16_value = 0;
+  uint16_t uint16_value = 0;
+  int32_t int32_value = 0;
+  uint32_t uint32_value = 0;
+  int64_t int64_value = 0;
+  uint64_t 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("v", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopVariantOfByte(&byte_value));
   ASSERT_EQ("v", reader.GetDataSignature());
   ASSERT_TRUE(reader.PopVariantOfBool(&bool_value));
@@ skipping 28 matching lines @@
   EXPECT_EQ(6, int64_value);
   EXPECT_EQ(7U, uint64_value);
   EXPECT_DOUBLE_EQ(8.0, double_value);
   EXPECT_EQ("string", string_value);
   EXPECT_EQ(ObjectPath("/object/path"), object_path_value);
 }
 
 TEST(MessageTest, ArrayOfBytes) {
   scoped_ptr<Response> message(Response::CreateEmpty());
   MessageWriter writer(message.get());
-  std::vector<uint8> bytes;
+  std::vector<uint8_t> 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;
+  const uint8_t* 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;
+  std::vector<uint8_t> bytes;
   writer.AppendArrayOfBytes(bytes.data(), bytes.size());
 
   MessageReader reader(message.get());
-  const uint8* output_bytes = NULL;
+  const uint8_t* 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());
@@ skipping 100 matching lines @@
         MessageWriter variant_writer(NULL);
         // Open a variant of a boolean.
         array_writer.OpenVariant("b", &variant_writer);
         variant_writer.AppendBool(true);
         array_writer.CloseContainer(&variant_writer);
       }
 
       // The second value in the array.
       {
         MessageWriter variant_writer(NULL);
-        // Open a variant of a struct that contains a string and an int32.
+        // Open a variant of a struct that contains a string and an int32_t.
         array_writer.OpenVariant("(si)", &variant_writer);
         {
           MessageWriter struct_writer(NULL);
           variant_writer.OpenStruct(&struct_writer);
           struct_writer.AppendString("string");
           struct_writer.AppendInt32(123);
           variant_writer.CloseContainer(&struct_writer);
         }
         array_writer.CloseContainer(&variant_writer);
       }
 
       // The third value in the array.
       {
         MessageWriter variant_writer(NULL);
-        // Open a variant of an array of string-to-int64 dict entries.
+        // Open a variant of an array of string-to-int64_t dict entries.
         array_writer.OpenVariant("a{sx}", &variant_writer);
         {
-          // Opens an array of string-to-int64 dict entries.
+          // Opens an array of string-to-int64_t dict entries.
           MessageWriter dict_array_writer(NULL);
           variant_writer.OpenArray("{sx}", &dict_array_writer);
           {
-            // Opens a string-to-int64 dict entries.
+            // Opens a string-to-int64_t dict entries.
             MessageWriter dict_entry_writer(NULL);
             dict_array_writer.OpenDictEntry(&dict_entry_writer);
             dict_entry_writer.AppendString("foo");
             dict_entry_writer.AppendInt64(INT64_C(1234567890123456789));
             dict_array_writer.CloseContainer(&dict_entry_writer);
           }
           variant_writer.CloseContainer(&dict_array_writer);
         }
         array_writer.CloseContainer(&variant_writer);
       }
     }
     writer.CloseContainer(&array_writer);
   }
   // What we have created looks like this:
-  EXPECT_EQ("message_type: MESSAGE_METHOD_RETURN\n"
-            "signature: av\n"
-            "\n"
-            "array [\n"
-            "  variant     bool true\n"
-            "  variant     struct {\n"
-            "      string \"string\"\n"
-            "      int32 123\n"
-            "    }\n"
-            "  variant     array [\n"
-            "      dict entry {\n"
-            "        string \"foo\"\n"
-            "        int64 1234567890123456789\n"
-            "      }\n"
-            "    ]\n"
-            "]\n",
-            message->ToString());
+  EXPECT_EQ(
+      "message_type: MESSAGE_METHOD_RETURN\n"
+      "signature: av\n"
+      "\n"
+      "array [\n"
+      "  variant     bool true\n"
+      "  variant     struct {\n"
+      "      string \"string\"\n"
+      "      int32_t 123\n"
+      "    }\n"
+      "  variant     array [\n"
+      "      dict entry {\n"
+      "        string \"foo\"\n"
+      "        int64_t 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;
+      int32_t 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;
+        int64_t int64_value = 0;
         ASSERT_TRUE(dict_entry_reader.PopInt64(&int64_value));
         EXPECT_EQ(INT64_C(1234567890123456789), int64_value);
       }
       ASSERT_FALSE(dict_array_reader.HasMoreData());
     }
     ASSERT_FALSE(variant_reader.HasMoreData());
   }
   ASSERT_FALSE(array_reader.HasMoreData());
   ASSERT_FALSE(reader.HasMoreData());
 }
@@ skipping 61 matching lines @@
 }
 
 TEST(MessageTest, Response) {
   scoped_ptr<Response> response(Response::CreateEmpty());
   EXPECT_TRUE(response->raw_message());
   EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType());
   EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString());
 }
 
 TEST(MessageTest, Response_FromMethodCall) {
-  const uint32 kSerial = 123;
+  const uint32_t kSerial = 123;
   MethodCall method_call("com.example.Interface", "SomeMethod");
   method_call.SetSerial(kSerial);
 
   scoped_ptr<Response> response(
       Response::FromMethodCall(&method_call));
   EXPECT_EQ(Message::MESSAGE_METHOD_RETURN, response->GetMessageType());
   EXPECT_EQ("MESSAGE_METHOD_RETURN", response->GetMessageTypeAsString());
   // The serial should be copied to the reply serial.
   EXPECT_EQ(kSerial, response->GetReplySerial());
 }
 
 TEST(MessageTest, ErrorResponse_FromMethodCall) {
-  const uint32 kSerial = 123;
+  const uint32_t kSerial = 123;
 const char kErrorMessage[] = "error message";
 
   MethodCall method_call("com.example.Interface", "SomeMethod");
   method_call.SetSerial(kSerial);
 
   scoped_ptr<ErrorResponse> error_response(
       ErrorResponse::FromMethodCall(&method_call,
                                     DBUS_ERROR_FAILED,
                                     kErrorMessage));
   EXPECT_EQ(Message::MESSAGE_ERROR, error_response->GetMessageType());
@@ skipping 78 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