Disable broken Android rtc_unittests.

webrtc/base/filerotatingstream_unittest.cc

 /*
  *  Copyright 2015 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <memory>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/filerotatingstream.h"
 #include "webrtc/base/fileutils.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/pathutils.h"
 
 namespace rtc {
 
-class FileRotatingStreamTest : public ::testing::Test {
+#if defined (WEBRTC_ANDROID)
+// Fails on Android: https://bugs.chromium.org/p/webrtc/issues/detail?id=4364.
+#define MAYBE_FileRotatingStreamTest DISABLED_FileRotatingStreamTest
+#else
+#define MAYBE_FileRotatingStreamTest FileRotatingStreamTest
+#endif
+
+class MAYBE_FileRotatingStreamTest : public ::testing::Test {

[pbos-webrtc, 2016/07/14 12:02:18]

You should disable the test and not the class of tests, right? E.g. MAYBE_State,
MAYBE_EmptyWrite and MAYBE_WriteAndRead instead of MAYBE_FileRotatingStreamTest.

[phoglund, 2016/07/14 15:16:27]

Mnyeh, all of them are broken anyway and it's quite possible it's a class-wide
problem, so this was less work.

[phoglund, 2016/07/14 15:33:06]

I should add: the two ways of doing it has the same effect, but it has the
drawback of being more work in case someone wants to enable just one of the
tests I disabled. Since all tests were broken I believe it's an issue on the
class level, so I think it's appropriate to disable the class here.

  protected:
   static const char* kFilePrefix;
   static const size_t kMaxFileSize;
 
   void Init(const std::string& dir_name,
             const std::string& file_prefix,
             size_t max_file_size,
             size_t num_log_files) {
     Pathname test_path;
     ASSERT_TRUE(Filesystem::GetAppTempFolder(&test_path));
@@ skipping 54 matching lines @@
     EXPECT_EQ(0, memcmp(expected_contents, buffer.get(), expected_length));
     size_t file_size = 0;
     EXPECT_TRUE(stream->GetSize(&file_size));
     EXPECT_EQ(file_size, expected_length);
   }
 
   std::unique_ptr<FileRotatingStream> stream_;
   std::string dir_path_;
 };
 
-const char* FileRotatingStreamTest::kFilePrefix = "FileRotatingStreamTest";
-const size_t FileRotatingStreamTest::kMaxFileSize = 2;
+const char* MAYBE_FileRotatingStreamTest::kFilePrefix =
+    "FileRotatingStreamTest";
+const size_t MAYBE_FileRotatingStreamTest::kMaxFileSize = 2;
 
 // Tests that stream state is correct before and after Open / Close.
-TEST_F(FileRotatingStreamTest, State) {
+TEST_F(MAYBE_FileRotatingStreamTest, State) {
   Init("FileRotatingStreamTestState", kFilePrefix, kMaxFileSize, 3);
 
   EXPECT_EQ(SS_CLOSED, stream_->GetState());
   ASSERT_TRUE(stream_->Open());
   EXPECT_EQ(SS_OPEN, stream_->GetState());
   stream_->Close();
   EXPECT_EQ(SS_CLOSED, stream_->GetState());
 }
 
 // Tests that nothing is written to file when data of length zero is written.
-TEST_F(FileRotatingStreamTest, EmptyWrite) {
+TEST_F(MAYBE_FileRotatingStreamTest, EmptyWrite) {
   Init("FileRotatingStreamTestEmptyWrite", kFilePrefix, kMaxFileSize, 3);
 
   ASSERT_TRUE(stream_->Open());
   WriteAndFlush("a", 0);
 
   std::string logfile_path = stream_->GetFilePath(0);
   std::unique_ptr<FileStream> stream(Filesystem::OpenFile(logfile_path, "r"));
   size_t file_size = 0;
   EXPECT_TRUE(stream->GetSize(&file_size));
   EXPECT_EQ(0u, file_size);
 }
 
 // Tests that a write operation followed by a read returns the expected data
 // and writes to the expected files.
-TEST_F(FileRotatingStreamTest, WriteAndRead) {
+TEST_F(MAYBE_FileRotatingStreamTest, WriteAndRead) {
   Init("FileRotatingStreamTestWriteAndRead", kFilePrefix, kMaxFileSize, 3);
 
   ASSERT_TRUE(stream_->Open());
   // The test is set up to create three log files of length 2. Write and check
   // contents.
   std::string messages[3] = {"aa", "bb", "cc"};
   for (size_t i = 0; i < arraysize(messages); ++i) {
     const std::string& message = messages[i];
     WriteAndFlush(message.c_str(), message.size());
     // Since the max log size is 2, we will be causing rotation. Read from the
@@ skipping 13 matching lines @@
   // TODO(tkchin): Maybe check all the files in the dir.
 
   // Reopen for read.
   std::string expected_contents("bbccd");
   VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
                    dir_path_, kFilePrefix);
 }
 
 // Tests that writing data greater than the total capacity of the files
 // overwrites the files correctly and is read correctly after.
-TEST_F(FileRotatingStreamTest, WriteOverflowAndRead) {
+TEST_F(MAYBE_FileRotatingStreamTest, WriteOverflowAndRead) {
   Init("FileRotatingStreamTestWriteOverflowAndRead", kFilePrefix, kMaxFileSize,
        3);
   ASSERT_TRUE(stream_->Open());
   // This should cause overflow across all three files, such that the first file
   // we wrote to also gets overwritten.
   std::string message("foobarbaz");
   WriteAndFlush(message.c_str(), message.size());
   std::string expected_file_contents("z");
   VerifyFileContents(expected_file_contents.c_str(),
                      expected_file_contents.size(), stream_->GetFilePath(0));
   std::string expected_stream_contents("arbaz");
   VerifyStreamRead(expected_stream_contents.c_str(),
                    expected_stream_contents.size(), dir_path_, kFilePrefix);
 }
 
 // Tests that the returned file paths have the right folder and prefix.
-TEST_F(FileRotatingStreamTest, GetFilePath) {
+TEST_F(MAYBE_FileRotatingStreamTest, GetFilePath) {
   Init("FileRotatingStreamTestGetFilePath", kFilePrefix, kMaxFileSize, 20);
   for (auto i = 0; i < 20; ++i) {
     Pathname path(stream_->GetFilePath(i));
     EXPECT_EQ(0, path.folder().compare(dir_path_));
     EXPECT_EQ(0, path.filename().compare(0, strlen(kFilePrefix), kFilePrefix));
   }
 }
 
-class CallSessionFileRotatingStreamTest : public ::testing::Test {
+#if defined (WEBRTC_ANDROID)
+// Fails on Android: https://bugs.chromium.org/p/webrtc/issues/detail?id=4364.
+#define MAYBE_CallSessionFileRotatingStreamTest \
+    DISABLED_CallSessionFileRotatingStreamTest
+#else
+#define MAYBE_CallSessionFileRotatingStreamTest \
+    CallSessionFileRotatingStreamTest
+#endif
+
+class MAYBE_CallSessionFileRotatingStreamTest : public ::testing::Test {
  protected:
   void Init(const std::string& dir_name, size_t max_total_log_size) {
     Pathname test_path;
     ASSERT_TRUE(Filesystem::GetAppTempFolder(&test_path));
     // Append per-test output path in order to run within gtest parallel.
     test_path.AppendFolder(dir_name);
     ASSERT_TRUE(Filesystem::CreateFolder(test_path));
     dir_path_ = test_path.pathname();
     ASSERT_TRUE(dir_path_.size());
     stream_.reset(
@@ skipping 32 matching lines @@
     EXPECT_EQ(SR_EOS, stream->ReadAll(buffer.get(), 1, nullptr, nullptr));
     EXPECT_EQ(stream_size, read);
   }
 
   std::unique_ptr<CallSessionFileRotatingStream> stream_;
   std::string dir_path_;
 };
 
 // Tests that writing and reading to a stream with the smallest possible
 // capacity works.
-TEST_F(CallSessionFileRotatingStreamTest, WriteAndReadSmallest) {
+TEST_F(DISABLED_CallSessionFileRotatingStreamTest, WriteAndReadSmallest) {
   Init("CallSessionFileRotatingStreamTestWriteAndReadSmallest", 4);
 
   ASSERT_TRUE(stream_->Open());
   std::string message("abcde");
   WriteAndFlush(message.c_str(), message.size());
   std::string expected_contents("abe");
   VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
                    dir_path_);
 }
 
 // Tests that writing and reading to a stream with capacity lesser than 4MB
 // behaves correctly.
-TEST_F(CallSessionFileRotatingStreamTest, WriteAndReadSmall) {
+TEST_F(DISABLED_CallSessionFileRotatingStreamTest, WriteAndReadSmall) {

[tommi, 2016/07/14 12:14:13]

Disabled for all?

[phoglund, 2016/07/14 15:16:27]

Done.

   Init("CallSessionFileRotatingStreamTestWriteAndReadSmall", 8);
 
   ASSERT_TRUE(stream_->Open());
   std::string message("123456789");
   WriteAndFlush(message.c_str(), message.size());
   std::string expected_contents("1234789");
   VerifyStreamRead(expected_contents.c_str(), expected_contents.size(),
                    dir_path_);
 }
 
 // Tests that writing and reading to a stream with capacity greater than 4MB
 // behaves correctly.
-TEST_F(CallSessionFileRotatingStreamTest, WriteAndReadLarge) {
+TEST_F(DISABLED_CallSessionFileRotatingStreamTest, WriteAndReadLarge) {

[tommi, 2016/07/14 12:14:13]

too?

[phoglund, 2016/07/14 15:16:27]

Done.

   Init("CallSessionFileRotatingStreamTestWriteAndReadLarge", 6 * 1024 * 1024);
 
   ASSERT_TRUE(stream_->Open());
   const size_t buffer_size = 1024 * 1024;
   std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   for (int i = 0; i < 8; i++) {
     memset(buffer.get(), i, buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->WriteAll(buffer.get(), buffer_size, nullptr, nullptr));
   }
 
   stream_.reset(new CallSessionFileRotatingStream(dir_path_));
   ASSERT_TRUE(stream_->Open());
   std::unique_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
   int expected_vals[] = {0, 1, 2, 6, 7};
   for (size_t i = 0; i < arraysize(expected_vals); ++i) {
     memset(expected_buffer.get(), expected_vals[i], buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->ReadAll(buffer.get(), buffer_size, nullptr, nullptr));
     EXPECT_EQ(0, memcmp(buffer.get(), expected_buffer.get(), buffer_size));
   }
   EXPECT_EQ(SR_EOS, stream_->ReadAll(buffer.get(), 1, nullptr, nullptr));
 }
 
 // Tests that writing and reading to a stream where only the first file is
 // written to behaves correctly.
-TEST_F(CallSessionFileRotatingStreamTest, WriteAndReadFirstHalf) {
+TEST_F(DISABLED_CallSessionFileRotatingStreamTest, WriteAndReadFirstHalf) {

[tommi, 2016/07/14 12:14:13]

ditto

[phoglund, 2016/07/14 15:16:27]

Done.

   Init("CallSessionFileRotatingStreamTestWriteAndReadFirstHalf",
        6 * 1024 * 1024);
   ASSERT_TRUE(stream_->Open());
   const size_t buffer_size = 1024 * 1024;
   std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   for (int i = 0; i < 2; i++) {
     memset(buffer.get(), i, buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->WriteAll(buffer.get(), buffer_size, nullptr, nullptr));
   }
 
   stream_.reset(new CallSessionFileRotatingStream(dir_path_));
   ASSERT_TRUE(stream_->Open());
   std::unique_ptr<uint8_t[]> expected_buffer(new uint8_t[buffer_size]);
   int expected_vals[] = {0, 1};
   for (size_t i = 0; i < arraysize(expected_vals); ++i) {
     memset(expected_buffer.get(), expected_vals[i], buffer_size);
     EXPECT_EQ(SR_SUCCESS,
               stream_->ReadAll(buffer.get(), buffer_size, nullptr, nullptr));
     EXPECT_EQ(0, memcmp(buffer.get(), expected_buffer.get(), buffer_size));
   }
   EXPECT_EQ(SR_EOS, stream_->ReadAll(buffer.get(), 1, nullptr, nullptr));
 }
 
 }  // namespace rtc