AAPT2: Rename to match new style

Use Google3 naming style to match new
projects' and open source google projects' style.

Preferred to do this in a massive CL so as to avoid
style inconsistencies that plague legacy code bases.
This is a relatively NEW code base, may as well keep
it up to date.

Test: name/style refactor - existing tests pass
Change-Id: Ie80ecb78d46ec53efdfca2336bb57d96cbb7fb87

1 files changed, 280 insertions, 237 deletions

diff --git a/tools/aapt2/java/JavaClassGenerator_test.cpp b/tools/aapt2/java/JavaClassGenerator_test.cpp
index ed7c6bd238b0..3d3d24e6aab5 100644
--- a/tools/aapt2/java/JavaClassGenerator_test.cpp
+++ b/tools/aapt2/java/JavaClassGenerator_test.cpp
@@ -15,154 +15,181 @@
  */
 
 #include "java/JavaClassGenerator.h"
-#include "test/Test.h"
-#include "util/Util.h"
 
 #include <sstream>
 #include <string>
 
+#include "test/Test.h"
+#include "util/Util.h"
+
 namespace aapt {
 
 TEST(JavaClassGeneratorTest, FailWhenEntryIsJavaKeyword) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:id/class", ResourceId(0x01020000))
-            .build();
-
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
-
-    std::stringstream out;
-    EXPECT_FALSE(generator.generate("android", &out));
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:id/class", ResourceId(0x01020000))
+          .Build();
+
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
+
+  std::stringstream out;
+  EXPECT_FALSE(generator.Generate("android", &out));
 }
 
 TEST(JavaClassGeneratorTest, TransformInvalidJavaIdentifierCharacter) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:id/hey-man", ResourceId(0x01020000))
-            .addValue("android:attr/cool.attr", ResourceId(0x01010000),
-                      test::AttributeBuilder(false).build())
-            .addValue("android:styleable/hey.dude", ResourceId(0x01030000),
-                      test::StyleableBuilder()
-                              .addItem("android:attr/cool.attr", ResourceId(0x01010000))
-                              .build())
-            .build();
-
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
-
-    std::stringstream out;
-    EXPECT_TRUE(generator.generate("android", &out));
-
-    std::string output = out.str();
-
-    EXPECT_NE(std::string::npos,
-              output.find("public static final int hey_man=0x01020000;"));
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:id/hey-man", ResourceId(0x01020000))
+          .AddValue("android:attr/cool.attr", ResourceId(0x01010000),
+                    test::AttributeBuilder(false).Build())
+          .AddValue(
+              "android:styleable/hey.dude", ResourceId(0x01030000),
+              test::StyleableBuilder()
+                  .AddItem("android:attr/cool.attr", ResourceId(0x01010000))
+                  .Build())
+          .Build();
+
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
+
+  std::stringstream out;
+  EXPECT_TRUE(generator.Generate("android", &out));
+
+  std::string output = out.str();
+
+  EXPECT_NE(std::string::npos,
+            output.find("public static final int hey_man=0x01020000;"));
+
+  EXPECT_NE(std::string::npos,
+            output.find("public static final int[] hey_dude={"));
+
+  EXPECT_NE(std::string::npos,
+            output.find("public static final int hey_dude_cool_attr=0;"));
+}
 
-    EXPECT_NE(std::string::npos,
-              output.find("public static final int[] hey_dude={"));
+TEST(JavaClassGeneratorTest, CorrectPackageNameIsUsed) {
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:id/one", ResourceId(0x01020000))
+          .AddSimple("android:id/com.foo$two", ResourceId(0x01020001))
+          .Build();
+
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
+  std::stringstream out;
+  ASSERT_TRUE(generator.Generate("android", "com.android.internal", &out));
+
+  std::string output = out.str();
+  EXPECT_NE(std::string::npos, output.find("package com.android.internal;"));
+  EXPECT_NE(std::string::npos,
+            output.find("public static final int one=0x01020000;"));
+  EXPECT_EQ(std::string::npos, output.find("two"));
+  EXPECT_EQ(std::string::npos, output.find("com_foo$two"));
+}
 
-    EXPECT_NE(std::string::npos,
-              output.find("public static final int hey_dude_cool_attr=0;"));
+TEST(JavaClassGeneratorTest, AttrPrivateIsWrittenAsAttr) {
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:attr/two", ResourceId(0x01010001))
+          .AddSimple("android:^attr-private/one", ResourceId(0x01010000))
+          .Build();
+
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
+  std::stringstream out;
+  ASSERT_TRUE(generator.Generate("android", &out));
+
+  std::string output = out.str();
+  EXPECT_NE(std::string::npos, output.find("public static final class attr"));
+  EXPECT_EQ(std::string::npos,
+            output.find("public static final class ^attr-private"));
 }
 
-TEST(JavaClassGeneratorTest, CorrectPackageNameIsUsed) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:id/one", ResourceId(0x01020000))
-            .addSimple("android:id/com.foo$two", ResourceId(0x01020001))
-            .build();
-
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
+TEST(JavaClassGeneratorTest, OnlyWritePublicResources) {
+  StdErrDiagnostics diag;
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:id/one", ResourceId(0x01020000))
+          .AddSimple("android:id/two", ResourceId(0x01020001))
+          .AddSimple("android:id/three", ResourceId(0x01020002))
+          .SetSymbolState("android:id/one", ResourceId(0x01020000),
+                          SymbolState::kPublic)
+          .SetSymbolState("android:id/two", ResourceId(0x01020001),
+                          SymbolState::kPrivate)
+          .Build();
+
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+
+  JavaClassGeneratorOptions options;
+  options.types = JavaClassGeneratorOptions::SymbolTypes::kPublic;
+  {
+    JavaClassGenerator generator(context.get(), table.get(), options);
     std::stringstream out;
-    ASSERT_TRUE(generator.generate("android", "com.android.internal", &out));
-
+    ASSERT_TRUE(generator.Generate("android", &out));
     std::string output = out.str();
-    EXPECT_NE(std::string::npos, output.find("package com.android.internal;"));
-    EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int one=0x01020000;"));
     EXPECT_EQ(std::string::npos, output.find("two"));
-    EXPECT_EQ(std::string::npos, output.find("com_foo$two"));
-}
+    EXPECT_EQ(std::string::npos, output.find("three"));
+  }
 
-TEST(JavaClassGeneratorTest, AttrPrivateIsWrittenAsAttr) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:attr/two", ResourceId(0x01010001))
-            .addSimple("android:^attr-private/one", ResourceId(0x01010000))
-            .build();
-
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
+  options.types = JavaClassGeneratorOptions::SymbolTypes::kPublicPrivate;
+  {
+    JavaClassGenerator generator(context.get(), table.get(), options);
     std::stringstream out;
-    ASSERT_TRUE(generator.generate("android", &out));
-
+    ASSERT_TRUE(generator.Generate("android", &out));
     std::string output = out.str();
-    EXPECT_NE(std::string::npos, output.find("public static final class attr"));
-    EXPECT_EQ(std::string::npos, output.find("public static final class ^attr-private"));
-}
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int one=0x01020000;"));
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int two=0x01020001;"));
+    EXPECT_EQ(std::string::npos, output.find("three"));
+  }
 
-TEST(JavaClassGeneratorTest, OnlyWritePublicResources) {
-    StdErrDiagnostics diag;
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:id/one", ResourceId(0x01020000))
-            .addSimple("android:id/two", ResourceId(0x01020001))
-            .addSimple("android:id/three", ResourceId(0x01020002))
-            .setSymbolState("android:id/one", ResourceId(0x01020000), SymbolState::kPublic)
-            .setSymbolState("android:id/two", ResourceId(0x01020001), SymbolState::kPrivate)
-            .build();
-
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-
-    JavaClassGeneratorOptions options;
-    options.types = JavaClassGeneratorOptions::SymbolTypes::kPublic;
-    {
-        JavaClassGenerator generator(context.get(), table.get(), options);
-        std::stringstream out;
-        ASSERT_TRUE(generator.generate("android", &out));
-        std::string output = out.str();
-        EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
-        EXPECT_EQ(std::string::npos, output.find("two"));
-        EXPECT_EQ(std::string::npos, output.find("three"));
-    }
-
-    options.types = JavaClassGeneratorOptions::SymbolTypes::kPublicPrivate;
-    {
-        JavaClassGenerator generator(context.get(), table.get(), options);
-        std::stringstream out;
-        ASSERT_TRUE(generator.generate("android", &out));
-        std::string output = out.str();
-        EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
-        EXPECT_NE(std::string::npos, output.find("public static final int two=0x01020001;"));
-        EXPECT_EQ(std::string::npos, output.find("three"));
-    }
-
-    options.types = JavaClassGeneratorOptions::SymbolTypes::kAll;
-    {
-        JavaClassGenerator generator(context.get(), table.get(), options);
-        std::stringstream out;
-        ASSERT_TRUE(generator.generate("android", &out));
-        std::string output = out.str();
-        EXPECT_NE(std::string::npos, output.find("public static final int one=0x01020000;"));
-        EXPECT_NE(std::string::npos, output.find("public static final int two=0x01020001;"));
-        EXPECT_NE(std::string::npos, output.find("public static final int three=0x01020002;"));
-    }
+  options.types = JavaClassGeneratorOptions::SymbolTypes::kAll;
+  {
+    JavaClassGenerator generator(context.get(), table.get(), options);
+    std::stringstream out;
+    ASSERT_TRUE(generator.Generate("android", &out));
+    std::string output = out.str();
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int one=0x01020000;"));
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int two=0x01020001;"));
+    EXPECT_NE(std::string::npos,
+              output.find("public static final int three=0x01020002;"));
+  }
 }
 
 /*
@@ -172,12 +199,15 @@ TEST(JavaClassGeneratorTest, OnlyWritePublicResources) {
                             ResourceId{ 0x01, 0x02, 0x0000 }));
     ResourceTable table;
     table.setPackage(u"com.lib");
-    ASSERT_TRUE(table.addResource(ResourceName{ {}, ResourceType::kId, u"test" }, {},
-                                  Source{ "lib.xml", 33 }, util::make_unique<Id>()));
+    ASSERT_TRUE(table.addResource(ResourceName{ {}, ResourceType::kId, u"test"
+}, {},
+                                  Source{ "lib.xml", 33 },
+util::make_unique<Id>()));
     ASSERT_TRUE(mTable->merge(std::move(table)));
 
     Linker linker(mTable,
-                  std::make_shared<MockResolver>(mTable, std::map<ResourceName, ResourceId>()),
+                  std::make_shared<MockResolver>(mTable, std::map<ResourceName,
+ResourceId>()),
                   {});
     ASSERT_TRUE(linker.linkAndValidate());
 
@@ -197,126 +227,139 @@ TEST(JavaClassGeneratorTest, OnlyWritePublicResources) {
 }*/
 
 TEST(JavaClassGeneratorTest, EmitOtherPackagesAttributesInStyleable) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-                .setPackageId("android", 0x01)
-                .setPackageId("com.lib", 0x02)
-                .addValue("android:attr/bar", ResourceId(0x01010000),
-                          test::AttributeBuilder(false).build())
-                .addValue("com.lib:attr/bar", ResourceId(0x02010000),
-                           test::AttributeBuilder(false).build())
-                .addValue("android:styleable/foo", ResourceId(0x01030000),
-                          test::StyleableBuilder()
-                                  .addItem("android:attr/bar", ResourceId(0x01010000))
-                                  .addItem("com.lib:attr/bar", ResourceId(0x02010000))
-                                  .build())
-                .build();
-
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
-
-    std::stringstream out;
-    EXPECT_TRUE(generator.generate("android", &out));
-
-    std::string output = out.str();
-    EXPECT_NE(std::string::npos, output.find("int foo_bar="));
-    EXPECT_NE(std::string::npos, output.find("int foo_com_lib_bar="));
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .SetPackageId("com.lib", 0x02)
+          .AddValue("android:attr/bar", ResourceId(0x01010000),
+                    test::AttributeBuilder(false).Build())
+          .AddValue("com.lib:attr/bar", ResourceId(0x02010000),
+                    test::AttributeBuilder(false).Build())
+          .AddValue("android:styleable/foo", ResourceId(0x01030000),
+                    test::StyleableBuilder()
+                        .AddItem("android:attr/bar", ResourceId(0x01010000))
+                        .AddItem("com.lib:attr/bar", ResourceId(0x02010000))
+                        .Build())
+          .Build();
+
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
+
+  std::stringstream out;
+  EXPECT_TRUE(generator.Generate("android", &out));
+
+  std::string output = out.str();
+  EXPECT_NE(std::string::npos, output.find("int foo_bar="));
+  EXPECT_NE(std::string::npos, output.find("int foo_com_lib_bar="));
 }
 
 TEST(JavaClassGeneratorTest, CommentsForSimpleResourcesArePresent) {
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addSimple("android:id/foo", ResourceId(0x01010000))
-            .build();
-    test::getValue<Id>(table.get(), "android:id/foo")
-            ->setComment(std::string("This is a comment\n@deprecated"));
-
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGenerator generator(context.get(), table.get(), {});
-    std::stringstream out;
-    ASSERT_TRUE(generator.generate("android", &out));
-    std::string actual = out.str();
-
-    const char* expectedText =
-R"EOF(/**
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddSimple("android:id/foo", ResourceId(0x01010000))
+          .Build();
+  test::GetValue<Id>(table.get(), "android:id/foo")
+      ->SetComment(std::string("This is a comment\n@deprecated"));
+
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGenerator generator(context.get(), table.get(), {});
+  std::stringstream out;
+  ASSERT_TRUE(generator.Generate("android", &out));
+  std::string actual = out.str();
+
+  const char* expectedText =
+      R"EOF(/**
      * This is a comment
      * @deprecated
      */
     @Deprecated
     public static final int foo=0x01010000;)EOF";
 
-    EXPECT_NE(std::string::npos, actual.find(expectedText));
+  EXPECT_NE(std::string::npos, actual.find(expectedText));
 }
 
-TEST(JavaClassGeneratorTest, CommentsForEnumAndFlagAttributesArePresent) {
-
-}
-
-TEST(JavaClassGeneratorTest, CommentsForStyleablesAndNestedAttributesArePresent) {
-    Attribute attr(false);
-    attr.setComment(StringPiece("This is an attribute"));
-
-    Styleable styleable;
-    styleable.entries.push_back(Reference(test::parseNameOrDie("android:attr/one")));
-    styleable.setComment(StringPiece("This is a styleable"));
-
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addValue("android:attr/one", util::make_unique<Attribute>(attr))
-            .addValue("android:styleable/Container",
-                      std::unique_ptr<Styleable>(styleable.clone(nullptr)))
-            .build();
-
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGeneratorOptions options;
-    options.useFinal = false;
-    JavaClassGenerator generator(context.get(), table.get(), options);
-    std::stringstream out;
-    ASSERT_TRUE(generator.generate("android", &out));
-    std::string actual = out.str();
-
-    EXPECT_NE(std::string::npos, actual.find("attr name android:one"));
-    EXPECT_NE(std::string::npos, actual.find("attr description"));
-    EXPECT_NE(std::string::npos, actual.find(attr.getComment().data()));
-    EXPECT_NE(std::string::npos, actual.find(styleable.getComment().data()));
+TEST(JavaClassGeneratorTest, CommentsForEnumAndFlagAttributesArePresent) {}
+
+TEST(JavaClassGeneratorTest,
+     CommentsForStyleablesAndNestedAttributesArePresent) {
+  Attribute attr(false);
+  attr.SetComment(StringPiece("This is an attribute"));
+
+  Styleable styleable;
+  styleable.entries.push_back(
+      Reference(test::ParseNameOrDie("android:attr/one")));
+  styleable.SetComment(StringPiece("This is a styleable"));
+
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddValue("android:attr/one", util::make_unique<Attribute>(attr))
+          .AddValue("android:styleable/Container",
+                    std::unique_ptr<Styleable>(styleable.Clone(nullptr)))
+          .Build();
+
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGeneratorOptions options;
+  options.use_final = false;
+  JavaClassGenerator generator(context.get(), table.get(), options);
+  std::stringstream out;
+  ASSERT_TRUE(generator.Generate("android", &out));
+  std::string actual = out.str();
+
+  EXPECT_NE(std::string::npos, actual.find("attr name android:one"));
+  EXPECT_NE(std::string::npos, actual.find("attr description"));
+  EXPECT_NE(std::string::npos, actual.find(attr.GetComment().data()));
+  EXPECT_NE(std::string::npos, actual.find(styleable.GetComment().data()));
 }
 
 TEST(JavaClassGeneratorTest, CommentsForRemovedAttributesAreNotPresentInClass) {
-    Attribute attr(false);
-    attr.setComment(StringPiece("removed"));
-
-    std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
-            .setPackageId("android", 0x01)
-            .addValue("android:attr/one", util::make_unique<Attribute>(attr))
-            .build();
-
-    std::unique_ptr<IAaptContext> context = test::ContextBuilder()
-            .addSymbolSource(util::make_unique<ResourceTableSymbolSource>(table.get()))
-            .setNameManglerPolicy(NameManglerPolicy{ "android" })
-            .build();
-    JavaClassGeneratorOptions options;
-    options.useFinal = false;
-    JavaClassGenerator generator(context.get(), table.get(), options);
-    std::stringstream out;
-    ASSERT_TRUE(generator.generate("android", &out));
-    std::string actual = out.str();
-
-    EXPECT_EQ(std::string::npos, actual.find("@attr name android:one"));
-    EXPECT_EQ(std::string::npos, actual.find("@attr description"));
-
-    // We should find @removed only in the attribute javadoc and not anywhere else (i.e. the class
-    // javadoc).
-    const size_t pos = actual.find("removed");
-    EXPECT_NE(std::string::npos, pos);
-    EXPECT_EQ(std::string::npos, actual.find("removed", pos + 1));
+  Attribute attr(false);
+  attr.SetComment(StringPiece("removed"));
+
+  std::unique_ptr<ResourceTable> table =
+      test::ResourceTableBuilder()
+          .SetPackageId("android", 0x01)
+          .AddValue("android:attr/one", util::make_unique<Attribute>(attr))
+          .Build();
+
+  std::unique_ptr<IAaptContext> context =
+      test::ContextBuilder()
+          .AddSymbolSource(
+              util::make_unique<ResourceTableSymbolSource>(table.get()))
+          .SetNameManglerPolicy(NameManglerPolicy{"android"})
+          .Build();
+  JavaClassGeneratorOptions options;
+  options.use_final = false;
+  JavaClassGenerator generator(context.get(), table.get(), options);
+  std::stringstream out;
+  ASSERT_TRUE(generator.Generate("android", &out));
+  std::string actual = out.str();
+
+  EXPECT_EQ(std::string::npos, actual.find("@attr name android:one"));
+  EXPECT_EQ(std::string::npos, actual.find("@attr description"));
+
+  // We should find @removed only in the attribute javadoc and not anywhere else
+  // (i.e. the class
+  // javadoc).
+  const size_t pos = actual.find("removed");
+  EXPECT_NE(std::string::npos, pos);
+  EXPECT_EQ(std::string::npos, actual.find("removed", pos + 1));
 }
 
-} // namespace aapt
+}  // namespace aapt