Use Google3 style guide with .clang-format

Test: style change only, builds ok
Change-Id: I885180e24cb2e7b58cfb4967c3bcb40058ce4078
diff --git a/tools/aapt2/compile/IdAssigner_test.cpp b/tools/aapt2/compile/IdAssigner_test.cpp
index d21fcba..ff7bf5c 100644
--- a/tools/aapt2/compile/IdAssigner_test.cpp
+++ b/tools/aapt2/compile/IdAssigner_test.cpp
@@ -22,154 +22,163 @@
 ::testing::AssertionResult verifyIds(ResourceTable* table);
 
 TEST(IdAssignerTest, AssignIds) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .addSimple("android:attr/foo")
-            .addSimple("android:attr/bar")
-            .addSimple("android:id/foo")
-            .setPackageId("android", 0x01)
-            .build();
+  std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
+                                             .addSimple("android:attr/foo")
+                                             .addSimple("android:attr/bar")
+                                             .addSimple("android:id/foo")
+                                             .setPackageId("android", 0x01)
+                                             .build();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-    IdAssigner assigner;
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  IdAssigner assigner;
 
-    ASSERT_TRUE(assigner.consume(context.get(), table.get()));
-    ASSERT_TRUE(verifyIds(table.get()));
+  ASSERT_TRUE(assigner.consume(context.get(), table.get()));
+  ASSERT_TRUE(verifyIds(table.get()));
 }
 
 TEST(IdAssignerTest, AssignIdsWithReservedIds) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .addSimple("android:id/foo", ResourceId(0x01010000))
-            .addSimple("android:dimen/two")
-            .addSimple("android:integer/three")
-            .addSimple("android:string/five")
-            .addSimple("android:attr/fun", ResourceId(0x01040000))
-            .addSimple("android:attr/foo", ResourceId(0x01040006))
-            .addSimple("android:attr/bar")
-            .addSimple("android:attr/baz")
-            .addSimple("app:id/biz")
-            .setPackageId("android", 0x01)
-            .setPackageId("app", 0x7f)
-            .build();
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .addSimple("android:id/foo", ResourceId(0x01010000))
+          .addSimple("android:dimen/two")
+          .addSimple("android:integer/three")
+          .addSimple("android:string/five")
+          .addSimple("android:attr/fun", ResourceId(0x01040000))
+          .addSimple("android:attr/foo", ResourceId(0x01040006))
+          .addSimple("android:attr/bar")
+          .addSimple("android:attr/baz")
+          .addSimple("app:id/biz")
+          .setPackageId("android", 0x01)
+          .setPackageId("app", 0x7f)
+          .build();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-    IdAssigner assigner;
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  IdAssigner assigner;
 
-    ASSERT_TRUE(assigner.consume(context.get(), table.get()));
-    ASSERT_TRUE(verifyIds(table.get()));
+  ASSERT_TRUE(assigner.consume(context.get(), table.get()));
+  ASSERT_TRUE(verifyIds(table.get()));
 
-    Maybe<ResourceTable::SearchResult> maybeResult;
+  Maybe<ResourceTable::SearchResult> maybeResult;
 
-    // Expect to fill in the gaps between 0x0101XXXX and 0x0104XXXX.
+  // Expect to fill in the gaps between 0x0101XXXX and 0x0104XXXX.
 
-    maybeResult = table->findResource(test::parseNameOrDie("android:dimen/two"));
-    AAPT_ASSERT_TRUE(maybeResult);
-    EXPECT_EQ(make_value<uint8_t>(2), maybeResult.value().type->id);
+  maybeResult = table->findResource(test::parseNameOrDie("android:dimen/two"));
+  AAPT_ASSERT_TRUE(maybeResult);
+  EXPECT_EQ(make_value<uint8_t>(2), maybeResult.value().type->id);
 
-    maybeResult = table->findResource(test::parseNameOrDie("android:integer/three"));
-    AAPT_ASSERT_TRUE(maybeResult);
-    EXPECT_EQ(make_value<uint8_t>(3), maybeResult.value().type->id);
+  maybeResult =
+      table->findResource(test::parseNameOrDie("android:integer/three"));
+  AAPT_ASSERT_TRUE(maybeResult);
+  EXPECT_EQ(make_value<uint8_t>(3), maybeResult.value().type->id);
 
-    // Expect to bypass the reserved 0x0104XXXX IDs and use the next 0x0105XXXX IDs.
+  // Expect to bypass the reserved 0x0104XXXX IDs and use the next 0x0105XXXX
+  // IDs.
 
-    maybeResult = table->findResource(test::parseNameOrDie("android:string/five"));
-    AAPT_ASSERT_TRUE(maybeResult);
-    EXPECT_EQ(make_value<uint8_t>(5), maybeResult.value().type->id);
+  maybeResult =
+      table->findResource(test::parseNameOrDie("android:string/five"));
+  AAPT_ASSERT_TRUE(maybeResult);
+  EXPECT_EQ(make_value<uint8_t>(5), maybeResult.value().type->id);
 
-    // Expect to fill in the gaps between 0x01040000 and 0x01040006.
+  // Expect to fill in the gaps between 0x01040000 and 0x01040006.
 
-    maybeResult = table->findResource(test::parseNameOrDie("android:attr/bar"));
-    AAPT_ASSERT_TRUE(maybeResult);
-    EXPECT_EQ(make_value<uint16_t>(1), maybeResult.value().entry->id);
+  maybeResult = table->findResource(test::parseNameOrDie("android:attr/bar"));
+  AAPT_ASSERT_TRUE(maybeResult);
+  EXPECT_EQ(make_value<uint16_t>(1), maybeResult.value().entry->id);
 
-    maybeResult = table->findResource(test::parseNameOrDie("android:attr/baz"));
-    AAPT_ASSERT_TRUE(maybeResult);
-    EXPECT_EQ(make_value<uint16_t>(2), maybeResult.value().entry->id);
+  maybeResult = table->findResource(test::parseNameOrDie("android:attr/baz"));
+  AAPT_ASSERT_TRUE(maybeResult);
+  EXPECT_EQ(make_value<uint16_t>(2), maybeResult.value().entry->id);
 }
 
 TEST(IdAssignerTest, FailWhenNonUniqueIdsAssigned) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .addSimple("android:attr/foo", ResourceId(0x01040006))
-            .addSimple("android:attr/bar", ResourceId(0x01040006))
-            .setPackageId("android", 0x01)
-            .setPackageId("app", 0x7f)
-            .build();
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .addSimple("android:attr/foo", ResourceId(0x01040006))
+          .addSimple("android:attr/bar", ResourceId(0x01040006))
+          .setPackageId("android", 0x01)
+          .setPackageId("app", 0x7f)
+          .build();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-    IdAssigner assigner;
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  IdAssigner assigner;
 
-    ASSERT_FALSE(assigner.consume(context.get(), table.get()));
+  ASSERT_FALSE(assigner.consume(context.get(), table.get()));
 }
 
 TEST(IdAssignerTest, AssignIdsWithIdMap) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .addSimple("android:attr/foo")
-            .addSimple("android:attr/bar")
-            .setPackageId("android", 0x01)
-            .build();
+  std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
+                                             .addSimple("android:attr/foo")
+                                             .addSimple("android:attr/bar")
+                                             .setPackageId("android", 0x01)
+                                             .build();
 
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
-    std::unordered_map<ResourceName, ResourceId> idMap = {
-            { test::parseNameOrDie("android:attr/foo"), ResourceId(0x01010002) } };
-    IdAssigner assigner(&idMap);
-    ASSERT_TRUE(assigner.consume(context.get(), table.get()));
-    ASSERT_TRUE(verifyIds(table.get()));
-    Maybe<ResourceTable::SearchResult> result = table->findResource(
-            test::parseNameOrDie("android:attr/foo"));
-    AAPT_ASSERT_TRUE(result);
+  std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
+  std::unordered_map<ResourceName, ResourceId> idMap = {
+      {test::parseNameOrDie("android:attr/foo"), ResourceId(0x01010002)}};
+  IdAssigner assigner(&idMap);
+  ASSERT_TRUE(assigner.consume(context.get(), table.get()));
+  ASSERT_TRUE(verifyIds(table.get()));
+  Maybe<ResourceTable::SearchResult> result =
+      table->findResource(test::parseNameOrDie("android:attr/foo"));
+  AAPT_ASSERT_TRUE(result);
 
-    const ResourceTable::SearchResult& searchResult = result.value();
-    EXPECT_EQ(make_value<uint8_t>(0x01), searchResult.package->id);
-    EXPECT_EQ(make_value<uint8_t>(0x01), searchResult.type->id);
-    EXPECT_EQ(make_value<uint16_t>(0x0002), searchResult.entry->id);
+  const ResourceTable::SearchResult& searchResult = result.value();
+  EXPECT_EQ(make_value<uint8_t>(0x01), searchResult.package->id);
+  EXPECT_EQ(make_value<uint8_t>(0x01), searchResult.type->id);
+  EXPECT_EQ(make_value<uint16_t>(0x0002), searchResult.entry->id);
 }
 
 ::testing::AssertionResult verifyIds(ResourceTable* table) {
-    std::set<uint8_t> packageIds;
-    for (auto& package : table->packages) {
-        if (!package->id) {
-            return ::testing::AssertionFailure() << "package " << package->name << " has no ID";
-        }
-
-        if (!packageIds.insert(package->id.value()).second) {
-            return ::testing::AssertionFailure() << "package " << package->name
-                    << " has non-unique ID " << std::hex << (int) package->id.value() << std::dec;
-        }
+  std::set<uint8_t> packageIds;
+  for (auto& package : table->packages) {
+    if (!package->id) {
+      return ::testing::AssertionFailure() << "package " << package->name
+                                           << " has no ID";
     }
 
-    for (auto& package : table->packages) {
-        std::set<uint8_t> typeIds;
-        for (auto& type : package->types) {
-            if (!type->id) {
-                return ::testing::AssertionFailure() << "type " << type->type << " of package "
-                        << package->name << " has no ID";
-            }
-
-            if (!typeIds.insert(type->id.value()).second) {
-                return ::testing::AssertionFailure() << "type " << type->type
-                        << " of package " << package->name << " has non-unique ID "
-                        << std::hex << (int) type->id.value() << std::dec;
-            }
-        }
-
-
-        for (auto& type : package->types) {
-            std::set<uint16_t> entryIds;
-            for (auto& entry : type->entries) {
-                if (!entry->id) {
-                    return ::testing::AssertionFailure() << "entry " << entry->name << " of type "
-                            << type->type << " of package " << package->name << " has no ID";
-                }
-
-                if (!entryIds.insert(entry->id.value()).second) {
-                    return ::testing::AssertionFailure() << "entry " << entry->name
-                            << " of type " << type->type << " of package " << package->name
-                            << " has non-unique ID "
-                            << std::hex << (int) entry->id.value() << std::dec;
-                }
-            }
-        }
+    if (!packageIds.insert(package->id.value()).second) {
+      return ::testing::AssertionFailure()
+             << "package " << package->name << " has non-unique ID " << std::hex
+             << (int)package->id.value() << std::dec;
     }
-    return ::testing::AssertionSuccess() << "all IDs are unique and assigned";
+  }
+
+  for (auto& package : table->packages) {
+    std::set<uint8_t> typeIds;
+    for (auto& type : package->types) {
+      if (!type->id) {
+        return ::testing::AssertionFailure() << "type " << type->type
+                                             << " of package " << package->name
+                                             << " has no ID";
+      }
+
+      if (!typeIds.insert(type->id.value()).second) {
+        return ::testing::AssertionFailure()
+               << "type " << type->type << " of package " << package->name
+               << " has non-unique ID " << std::hex << (int)type->id.value()
+               << std::dec;
+      }
+    }
+
+    for (auto& type : package->types) {
+      std::set<uint16_t> entryIds;
+      for (auto& entry : type->entries) {
+        if (!entry->id) {
+          return ::testing::AssertionFailure()
+                 << "entry " << entry->name << " of type " << type->type
+                 << " of package " << package->name << " has no ID";
+        }
+
+        if (!entryIds.insert(entry->id.value()).second) {
+          return ::testing::AssertionFailure()
+                 << "entry " << entry->name << " of type " << type->type
+                 << " of package " << package->name << " has non-unique ID "
+                 << std::hex << (int)entry->id.value() << std::dec;
+        }
+      }
+    }
+  }
+  return ::testing::AssertionSuccess() << "all IDs are unique and assigned";
 }
 
-} // namespace aapt
+}  // namespace aapt