Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 90d3fb63 authored by weisu's avatar weisu
Browse files

Write files in a temporary directory 

Avoid writing test files in the build output directory which fails when
run with Bazel. This happens because Bazel's sandboxing environment
ensures that the test's working directory is unwritable.

See https://docs.bazel.build/versions/main/sandboxing.html for more
information.

Bug: 209687942
Test: atest --bazel-mode aapt2_tests
Test: atest aapt2_tests

Change-Id: I0fce701bbac255c3e308ad5c85aa27230c3b620b
parent d5bd8472

tools/aapt2/cmd/Compile_test.cpp

+29 −35
Original line number Diff line number Diff line
@@ -19,12 +19,11 @@ 
#include "android-base/file.h"

#include "android-base/stringprintf.h"

#include "android-base/utf8.h"



#include "format/proto/ProtoDeserialize.h"

#include "io/StringStream.h"

#include "io/ZipArchive.h"

#include "java/AnnotationProcessor.h"

#include "test/Test.h"

#include "format/proto/ProtoDeserialize.h"



namespace aapt {
@@ -59,55 +58,56 @@ TEST_F(CompilerTest, MultiplePeriods) { 
  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();

  const std::string kResDir = BuildPath({android::base::Dirname(android::base::GetExecutablePath()),

                                         "integration-tests", "CompileTest", "res"});

  const std::string kOutDir = testing::TempDir();



  // Resource files without periods in the file name should not throw errors

  const std::string path0 = BuildPath({kResDir, "values", "values.xml"});

  const std::string path0_out = BuildPath({kResDir, "values_values.arsc.flat"});

  const std::string path0_out = BuildPath({kOutDir, "values_values.arsc.flat"});

  ::android::base::utf8::unlink(path0_out.c_str());

  ASSERT_EQ(TestCompile(path0, kResDir, /** legacy */ false, diag), 0);

  ASSERT_EQ(TestCompile(path0, kOutDir, /** legacy */ false, diag), 0);

  ASSERT_EQ(::android::base::utf8::unlink(path0_out.c_str()), 0);

  ASSERT_EQ(TestCompile(path0, kResDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(TestCompile(path0, kOutDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(::android::base::utf8::unlink(path0_out.c_str()), 0);



  const std::string path1 = BuildPath({kResDir, "drawable", "image.png"});

  const std::string path1_out = BuildPath({kResDir, "drawable_image.png.flat"});

  const std::string path1_out = BuildPath({kOutDir, "drawable_image.png.flat"});

  ::android::base::utf8::unlink(path1_out.c_str());

  ASSERT_EQ(TestCompile(path1, kResDir, /** legacy */ false, diag), 0);

  ASSERT_EQ(TestCompile(path1, kOutDir, /** legacy */ false, diag), 0);

  ASSERT_EQ(::android::base::utf8::unlink(path1_out.c_str()), 0);

  ASSERT_EQ(TestCompile(path1, kResDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(TestCompile(path1, kOutDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(::android::base::utf8::unlink(path1_out.c_str()), 0);



  const std::string path2 = BuildPath({kResDir, "drawable", "image.9.png"});

  const std::string path2_out = BuildPath({kResDir, "drawable_image.9.png.flat"});

  const std::string path2_out = BuildPath({kOutDir, "drawable_image.9.png.flat"});

  ::android::base::utf8::unlink(path2_out.c_str());

  ASSERT_EQ(TestCompile(path2, kResDir, /** legacy */ false, diag), 0);

  ASSERT_EQ(TestCompile(path2, kOutDir, /** legacy */ false, diag), 0);

  ASSERT_EQ(::android::base::utf8::unlink(path2_out.c_str()), 0);

  ASSERT_EQ(TestCompile(path2, kResDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(TestCompile(path2, kOutDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(::android::base::utf8::unlink(path2_out.c_str()), 0);



  // Resource files with periods in the file name should fail on non-legacy compilations

  const std::string path3 = BuildPath({kResDir, "values", "values.all.xml"});

  const std::string path3_out = BuildPath({kResDir, "values_values.all.arsc.flat"});

  const std::string path3_out = BuildPath({kOutDir, "values_values.all.arsc.flat"});

  ::android::base::utf8::unlink(path3_out.c_str());

  ASSERT_NE(TestCompile(path3, kResDir, /** legacy */ false, diag), 0);

  ASSERT_NE(TestCompile(path3, kOutDir, /** legacy */ false, diag), 0);

  ASSERT_NE(::android::base::utf8::unlink(path3_out.c_str()), 0);

  ASSERT_EQ(TestCompile(path3, kResDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(TestCompile(path3, kOutDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(::android::base::utf8::unlink(path3_out.c_str()), 0);



  const std::string path4 = BuildPath({kResDir, "drawable", "image.small.png"});

  const std::string path4_out = BuildPath({kResDir, "drawable_image.small.png.flat"});

  const std::string path4_out = BuildPath({kOutDir, "drawable_image.small.png.flat"});

  ::android::base::utf8::unlink(path4_out.c_str());

  ASSERT_NE(TestCompile(path4, kResDir, /** legacy */ false, diag), 0);

  ASSERT_NE(TestCompile(path4, kOutDir, /** legacy */ false, diag), 0);

  ASSERT_NE(::android::base::utf8::unlink(path4_out.c_str()), 0);

  ASSERT_EQ(TestCompile(path4, kResDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(TestCompile(path4, kOutDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(::android::base::utf8::unlink(path4_out.c_str()), 0);



  const std::string path5 = BuildPath({kResDir, "drawable", "image.small.9.png"});

  const std::string path5_out = BuildPath({kResDir, "drawable_image.small.9.png.flat"});

  const std::string path5_out = BuildPath({kOutDir, "drawable_image.small.9.png.flat"});

  ::android::base::utf8::unlink(path5_out.c_str());

  ASSERT_NE(TestCompile(path5, kResDir, /** legacy */ false, diag), 0);

  ASSERT_NE(TestCompile(path5, kOutDir, /** legacy */ false, diag), 0);

  ASSERT_NE(::android::base::utf8::unlink(path5_out.c_str()), 0);

  ASSERT_EQ(TestCompile(path5, kResDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(TestCompile(path5, kOutDir, /** legacy */ true, diag), 0);

  ASSERT_EQ(::android::base::utf8::unlink(path5_out.c_str()), 0);

}
@@ -116,9 +116,7 @@ TEST_F(CompilerTest, DirInput) { 
  std::unique_ptr<IAaptContext> context = test::ContextBuilder().Build();

  const std::string kResDir = BuildPath({android::base::Dirname(android::base::GetExecutablePath()),

                                         "integration-tests", "CompileTest", "DirInput", "res"});

  const std::string kOutputFlata =

      BuildPath({android::base::Dirname(android::base::GetExecutablePath()), "integration-tests",

                 "CompileTest", "DirInput", "compiled.flata"});

  const std::string kOutputFlata = BuildPath({testing::TempDir(), "compiled.flata"});

  ::android::base::utf8::unlink(kOutputFlata.c_str());



  std::vector<android::StringPiece> args;
@@ -147,9 +145,7 @@ TEST_F(CompilerTest, ZipInput) { 
  const std::string kResZip =

      BuildPath({android::base::Dirname(android::base::GetExecutablePath()), "integration-tests",

                 "CompileTest", "ZipInput", "res.zip"});

  const std::string kOutputFlata =

      BuildPath({android::base::Dirname(android::base::GetExecutablePath()), "integration-tests",

                 "CompileTest", "ZipInput", "compiled.flata"});

  const std::string kOutputFlata = BuildPath({testing::TempDir(), "compiled.flata"});



  ::android::base::utf8::unlink(kOutputFlata.c_str());
@@ -257,9 +253,9 @@ TEST_F(CompilerTest, DoNotTranslateTest) { 


TEST_F(CompilerTest, RelativePathTest) {

  StdErrDiagnostics diag;

  const std::string res_path = BuildPath(

      {android::base::Dirname(android::base::GetExecutablePath()),

       "integration-tests", "CompileTest", "res"});

  const std::string res_path =

      BuildPath({android::base::Dirname(android::base::GetExecutablePath()), "integration-tests",

                 "CompileTest", "res"});



  const std::string path_values_colors = GetTestPath("values/colors.xml");

  WriteFile(path_values_colors, "<resources>"
@@ -272,9 +268,8 @@ TEST_F(CompilerTest, RelativePathTest) { 
                   "<TextBox android:id=\"@+id/text_one\" android:background=\"@color/color_one\"/>"

                   "</LinearLayout>");



  const std::string compiled_files_dir  = BuildPath(

      {android::base::Dirname(android::base::GetExecutablePath()),

       "integration-tests", "CompileTest", "compiled"});

  const std::string compiled_files_dir =

      BuildPath({testing::TempDir(), "integration-tests", "CompileTest", "compiled"});

  CHECK(file::mkdirs(compiled_files_dir.data()));



  const std::string path_values_colors_out =
@@ -283,9 +278,8 @@ TEST_F(CompilerTest, RelativePathTest) { 
      BuildPath({compiled_files_dir, "layout_layout_one.flat"});

  ::android::base::utf8::unlink(path_values_colors_out.c_str());

  ::android::base::utf8::unlink(path_layout_layout_one_out.c_str());

  const std::string apk_path = BuildPath(

      {android::base::Dirname(android::base::GetExecutablePath()),

       "integration-tests", "CompileTest", "out.apk"});

  const std::string apk_path =

      BuildPath({testing::TempDir(), "integration-tests", "CompileTest", "out.apk"});



  const std::string source_set_res = BuildPath({"main", "res"});

  const std::string relative_path_values_colors =

tools/aapt2/test/Fixture.cpp

+2 −3
Original line number Diff line number Diff line
@@ -67,8 +67,7 @@ void ClearDirectory(const android::StringPiece& path) { 
}



void TestDirectoryFixture::SetUp() {

  temp_dir_ = file::BuildPath({android::base::GetExecutableDirectory(),

                               "_temp",

  temp_dir_ = file::BuildPath({testing::TempDir(), "_temp",

                               testing::UnitTest::GetInstance()->current_test_case()->name(),

                               testing::UnitTest::GetInstance()->current_test_info()->name()});

  ASSERT_TRUE(file::mkdirs(temp_dir_));