[libc] add buffering to FILE writes

[michaelrj]

Summary

Previously all FILE objects were fully buffered, this patch adds line
buffering and unbuffered output, as well as applying them to stdout and
stderr.

[sivachandra]

libc/src/__support/File/file.cpp

34

These additional conditionals are making the code even more complicated. Instead, we should do this: rename the current write_unlocked method to write_unlocked_fully_buffered and make it private. Next, add two new methods like this:

public:
size_t write_unlocked(const void *data, size_t len) {
  if (bufmode == _IOLBF) {
    return write_unlocked_line_buffered(data, len);
  } else if (bufmode == _IOFBF) {
    return write_unlocked_fully_buffered(data, len);
  } else {
    size_t written_size =platform_write(this, data, len);
    // Error handling if platform_write fails.

    platform_flush(this);

    // Error handling if platform_flush fails

    return len;
  }
}

private:
size_t write_unlocked_line_buffered(const void *data, size_t len) {
  // Instead of looking for the first new line char, look for the last new line char.
  char *last = last_newline(data, len);
  if (last == nullptr) {
   // If no new line char is found, just do normal buffering.
    return write_unlocked_fully_buffered(data, len);
  }

  size_t written_size;
  if (pos == 0) {
    // If there is no content in the buffer, write out the new data.
    written_size = platform_write(data, last - data /* size including the new line char */);
    // Perform error handling
  } else {
    // First write out the existing content, and then write out the new data.
    platform_write(buf, pos);
    // Perform error handling
    pos = 0;

    written_size = platform_write(data, last - data);
    // Perform error handling.
  }


  platform_flush();

  // Perform error handling

  if (written_size == len)
    return len;

  // Remaining data should be buffered.
  written_size = write_unlocked_fully_buffered(data + written_size, len - written_size);

  // Perform error handling

  return len;
}

libc/src/__support/File/file.h

62

We shouldn't need this, and may be even not do this. Add the macros _IOFBF etc. to stdio.h and use them directly.

libc/src/__support/File/linux_file.cpp

161

Shouldn't the default buffering mode be _IOFBF?

173–174

We don't need these anymore - just make the size arg 0 and buffer arg nullptr in the constructor call below.

libc/test/src/__support/File/file_test.cpp

110

Why did you change this to calloc?

[michaelrj]

rewrite to be closer to the original

libc/src/__support/File/file.cpp

34

I don't think splitting line buffered and fully buffered writes is the correct design. The reason being that their logic is almost identical, only varying in the spot where they flush the buffer. With this idea in mind, I've rewritten the original function to support both types of buffering in a manner closer to your original design. I've also kept unbuffered writes in this function, since it seems odd to split just that function off on its own if all the other write modes are together.

[sivachandra]

libc/src/__support/File/file.cpp

34

The concept of a flush_point is promising but in the current state of this patch, I am not yet convinced.

68

While the concept of flush_point seems promising, I think there is a mix up of a xfer_point and a flush_point in the code below. You want to transfer and clear the libc buffer when it is full. But, under _IOLBF, you want to actually perform the flush operation. May be I am missing it, but I don't see any call to platform_flush after this line.

74

It took me some time to understand why this return is OK. Which probably means we need to refactor/rename/comment.

75

If the if has braces, else should also have braces.

82–83

Should this be:

size_t remaining = len - write_size;

86

Should remaining be updated inside this if block? Couple of points:

1. It seems like the condition is true only for a specific case of _IOLBF.
2. This condition can be true even if there is no newline char in the input?

91

Is an else missing here?

93

This condition can be true if flush_point - write_size is less than remaining?

[michaelrj]

address comments

libc/src/__support/File/file.cpp

68

I've added a call to flush at the end.

82–83

in this case remaining represents the number of characters left after the flush point. This is useful, since we want to know if the characters after the flush point will fit into the buffer, and if they will we want to write everything to output directly.

86

no, since it's only tracking the number of characters after the flush point, and from that the number of characters written should be logical after each step.

This isn't only true in a special case of line buffered mode, but it is related to that. This handles the case where the flush point is after the end of the buffer, as well as the cases where the remainder after the flush point doesn't fit into the buffer. The flush point can only be after the end of the buffer if there's a newline, because otherwise the flush point is equal to the end of the buffer.

It should be able to be true if there's no newline in the input, that's a good catch. I've added an extra condition.

91

no, but there used to be one here. If this were only fully buffered then writing remaining to the buffer and writing from data to the output directly would never happen together, but in line buffered mode in the case where the newline is after the end of the buffer, but the characters after the newline fit into the buffer, we might need to do both.

[sivachandra]

While this is probably OK logically, it is way harder to reason than before. I am not yet convinced that this idea of flush_point and mixing line buffering and fully buffering is better.

I gave it one pass and will need at least one more to actually understand everything. I will do it once more and get back to you.

[michaelrj]

change to a simpler algorithm

[sivachandra]

The idea of "split point" makes it almost equivalent to the split approach I proposed. Taking a step back and looking at it objectively, consider that once a file is in a buffering mode, it is in that mode for its life time. Likewise, FBF is a mode by itself but LBF is FBF plus something else. To reflect these conceptual notions in code, we should use the approach of building LBF over FBF. That will keep FBF and LBF implementations simple and focused. Quantitatively also, the current state of this patch demonstrates that mixing makes it more complicated than it was previously.

I was wrong in expecting that concepts like flush point would make the implementation simple so I apologize for the misleading feedback I have given earlier. To move forward, we will do this:

1. Use the split approach of building LBF over FBF as I have suggested earlier.
2. Fix any bugs in FBF implementation separately.
3. If and when some optimizations are required, we will optimize based on the data about what exactly the problem is.

[michaelrj]

split the buffering modes into different functions, as well as cleaning up each implementation to be simpler in its specific case.

[sivachandra]

Good to go after the comments addressed.

libc/src/__support/File/file.cpp

117

We will keep the implementation simple for now like this:

fbf(primary.data(), primary.size());
// Error check
flush_unlocked(); // A call to flush and not to platform_flush()
fbf(remaining.data(), remaining.size());
// Error check

It should incur the same number of platform_* calls but might lead to a few additional copies. Iff required, we can optimize FBF to eliminate the unecessary copies. Infact, what we really want is to replace the first FBF operation by an NBF operation. We can do all that iff required.

I don't think we have flush_unlocked, so you will have to add it.

libc/test/src/__support/File/file_test.cpp

153

It will be cool to actually create an FBF file also and show the difference in pos comparisons (like those on line 170 and 174).

397

_IOFBF?

411

Use some buffering mode. Or, test for all modes.

[michaelrj]

address comments

libc/src/__support/File/file.cpp

117

I did add NBF as well as flush_unlocked, and now we're down to three platform writes maximum (one for the buffer, one for the section up to the newline, and one for the remainder).

[sivachandra]

LGTM modulo one comment about the NBF operation.

libc/src/__support/File/file.cpp

52

You should have an else which does platfrom_flush()?

84

You shouldn't need this as the NBF operation does platform flush anyway. My previous comment suggested this assuming FBF on line 163.

[michaelrj]

libc/src/__support/File/file.cpp

52

I have the flush outside of the unbuffered write so that in the fully buffered function (line 63) we can use the unbuffered write when the data is too large for the buffer. This means that in the base write_unlocked function and in write_unlocked_lbf we have to flush separately, but I think that's okay.

[sivachandra]

libc/src/__support/File/file.cpp

52

Ah, I missed that!

libc/src/__support/File/file.h

enum class ContentType : ModeFlags {
     BINARY = 0x10,
   };
 
   // Denotes a file to be created for writing.
   enum class CreateType : ModeFlags {
     EXCLUSIVE = 0x100,
   };
 
+  static constexpr int FULLY_BUFFERED = 0;
+  static constexpr int LINE_BUFFERED = 1;
+  static constexpr int UNBUFFERED = 2;
+
 private:
   enum class FileOp : uint8_t { NONE, READ, WRITE, SEEK };
 
   // Platfrom specific functions which create new file objects should initialize
   // these fields suitably via the constructor. Typically, they should be simple
   // syscall wrappers for the corresponding functionality.
   WriteFunc *platform_write;
   ReadFunc *platform_read;

libc/src/__support/File/file.cpp

size_t File::write_unlocked(const void *data, size_t len) {
   if (!write_allowed()) {
     errno = EBADF;
     err = true;
     return 0;
   }
 
   prev_op = FileOp::WRITE;
 
+  if (bufmode == UNBUFFERED) {
+    size_t written = platform_write(this, data, len);
+    if (written < len)
+      err = true;
+    platform_flush(this);
+    return written;
+  }
   cpp::ArrayRef<uint8_t> dataref(data, len);
   cpp::MutableArrayRef<uint8_t> bufref(buf, bufsize);
 
-  const size_t used = pos;
+  size_t written = 0;
+
+  while (written < len) {
     const size_t bufspace = bufsize - pos;
-  const size_t write_size = bufspace > len ? len : bufspace;
+    size_t write_size = bufspace > (len - written) ? (len - written) : bufspace;
+    if (bufmode == LINE_BUFFERED) {
+      size_t newline_pos;
+      for (newline_pos = 0; newline_pos < write_size; ++newline_pos) {
+        if (dataref[newline_pos + written] == '\n') {
+          write_size = newline_pos + 1; // include the newline in the write
+          break;
+        }
+      }
+    }
     // TODO: Replace the for loop below with a call to internal memcpy.
     for (size_t i = 0; i < write_size; ++i)
-    bufref[pos + i] = dataref[i];
+      bufref[pos + i] = dataref[i + written];
+    written += write_size;
     pos += write_size;
-  if (len < bufspace)
-    return len;
 
-  // If the control reaches beyond this point, it means that |data|
-  // is more than what can be accomodated in the buffer. So, we first
-  // flush out the buffer.
-  size_t bytes_written = platform_write(this, buf, bufsize);
+    // if we've written all of the characters and the buffer shouldn't be
+    // flushed, skip to the end and don't flush the buffer.
+    if (written == len && pos < bufsize &&
+        !(bufmode == LINE_BUFFERED && bufref[pos - 1] == '\n'))
+      break;
+
+    // If the control reaches beyond this point, the buffer is intended to be
+    // flushed.
+    size_t to_write = pos; // a copy for later comparisons
+    size_t bytes_written = platform_write(this, buf, to_write);
+
     pos = 0; // Buffer is now empty so reset pos to the beginning.
-  if (bytes_written < bufsize) {
+    if (bytes_written < to_write) {
       err = true;
       // If less bytes were written than expected, then there are two
       // possibilities.
       // 1. None of the bytes from |data| were flushed out.
-    if (bytes_written <= used)
-      return 0;
+      if (static_cast<int>(bytes_written) <
+          static_cast<int>(to_write - written))
+        return 0; // this comparison has to be signed in case written > to_write
       // 2. Some of the bytes from |data| were written
-    return bytes_written - used;
+      return written - (to_write - bytes_written);
     }
-
-  // If the remaining bytes from |data| can fit in the buffer, write
-  // into it. Else, write it directly to the platform stream.
-  size_t remaining = len - write_size;
-  if (remaining <= len) {
-    // TODO: Replace the for loop below with a call to internal memcpy.
-    for (size_t i = 0; i < remaining; ++i)
-      bufref[i] = dataref[i];
-    pos += remaining;
-    return len;
   }
 
-  size_t transferred =
-      platform_write(this, dataref.data() + write_size, remaining);
-  if (transferred < remaining) {
-    err = true;
-    return write_size + transferred;
-  }
-  return len;
+  return written;
 }
 
 size_t File::read_unlocked(void *data, size_t len) {
   if (!read_allowed()) {
     errno = EBADF;
     err = true;
     return 0;
   }
 
   prev_op = FileOp::READ;
 
   cpp::MutableArrayRef<uint8_t> bufref(buf, bufsize);
   cpp::MutableArrayRef<uint8_t> dataref(data, len);
 
   // Because read_limit is always greater than equal to pos,
   // available_data is never a wrapped around value.
   size_t available_data = read_limit - pos;
   if (len <= available_data) {
     // TODO: Replace the for loop below with a call to internal memcpy.
     for (size_t i = 0; i < len; ++i)
       dataref[i] = bufref[i + pos];
     pos += len;
     return len;
   }
 
   // Copy all of the available data.
   // TODO: Replace the for loop with a call to internal memcpy.
   for (size_t i = 0; i < available_data; ++i)
     dataref[i] = bufref[i + pos];
   read_limit = pos = 0; // Reset the pointers.
 
   size_t to_fetch = len - available_data;
   if (to_fetch > bufsize) {
     size_t fetched_size = platform_read(this, data, to_fetch);
     if (fetched_size < to_fetch) {
       if (errno == 0)
         eof = true;
       else
         err = true;
       return available_data + fetched_size;
     }
     return len;

libc/src/__support/File/linux_file.cpp

#endif
 
   if (fd < 0) {
     errno = -fd;
     return nullptr;
   }
 
   void *buffer = malloc(File::DEFAULT_BUFFER_SIZE);
   auto *file = reinterpret_cast<LinuxFile *>(malloc(sizeof(LinuxFile)));
-  LinuxFile::init(
-      file, fd, buffer, File::DEFAULT_BUFFER_SIZE,
-      0, // TODO: Set the correct buffer mode when buffer mode is available.
+  LinuxFile::init(file, fd, buffer, File::DEFAULT_BUFFER_SIZE, File::UNBUFFERED,
                   true, modeflags);
   return file;
 }
 
-// TODO: Use the appropriate buffering modes for the standard streams below
-// the different buffering modes are available.
 constexpr size_t STDOUT_BUFFER_SIZE = 1024;
 char stdout_buffer[STDOUT_BUFFER_SIZE];
-static LinuxFile StdOut(1, stdout_buffer, STDOUT_BUFFER_SIZE, 0, false,
+static LinuxFile StdOut(1, stdout_buffer, STDOUT_BUFFER_SIZE,
+                        File::LINE_BUFFERED, false,
                         File::ModeFlags(File::OpenMode::APPEND));
 File *stdout = &StdOut;
 
 constexpr size_t STDERR_BUFFER_SIZE = 1024;
 char stderr_buffer[STDERR_BUFFER_SIZE];
-static LinuxFile StdErr(2, stderr_buffer, STDERR_BUFFER_SIZE, 0, false,
-                        File::ModeFlags(File::OpenMode::APPEND));
+static LinuxFile StdErr(2, stderr_buffer, STDERR_BUFFER_SIZE, File::UNBUFFERED,
+                        false, File::ModeFlags(File::OpenMode::APPEND));
 File *stderr = &StdErr;
 
 } // namespace __llvm_libc

libc/test/src/__support/File/file_test.cpp

if (whence == SEEK_CUR)
     sf->pos += offset;
   if (whence == SEEK_END)
     sf->pos = SIZE + offset;
   return 0;
 }
 
 StringFile *new_string_file(char *buffer, size_t buflen, int bufmode,
                             bool owned, const char *mode) {
-  StringFile *f = reinterpret_cast<StringFile *>(malloc(sizeof(StringFile)));
+  StringFile *f = reinterpret_cast<StringFile *>(calloc(1, sizeof(StringFile)));
   f->init(buffer, buflen, bufmode, owned, __llvm_libc::File::mode_flags(mode));
   return f;
 }
 
 TEST(LlvmLibcFileTest, WriteOnly) {
   const char data[] = "hello, file";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
   char file_buffer[FILE_BUFFER_SIZE];
-  StringFile *f = new_string_file(file_buffer, FILE_BUFFER_SIZE, 0, false, "w");
+  StringFile *f =
+      new_string_file(file_buffer, FILE_BUFFER_SIZE,
+                      __llvm_libc::File::FULLY_BUFFERED, false, "w");
 
   ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
   EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
   ASSERT_EQ(f->flush(), 0);
   EXPECT_EQ(f->get_pos(), sizeof(data)); // Data should now be available
   EXPECT_STREQ(f->get_str(), data);
 
   f->reset();
TEST(LlvmLibcFileTest, WriteOnly) {
   EXPECT_EQ(f->read(read_data, sizeof(data)), size_t(0));
   EXPECT_TRUE(f->error());
   EXPECT_NE(errno, 0);
   errno = 0;
 
   ASSERT_EQ(f->close(), 0);
 }
 
+TEST(LlvmLibcFileTest, WriteLineBuffered) {
+  const char data[] = "hello\n file";
+  constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
+  char file_buffer[FILE_BUFFER_SIZE];
+  StringFile *f = new_string_file(file_buffer, FILE_BUFFER_SIZE,
+                                  __llvm_libc::File::LINE_BUFFERED, false, "w");
+
+  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
+  EXPECT_EQ(f->get_pos(), size_t(6)); // buffer after the newline
+  EXPECT_STREQ(f->get_str(), "hello\n");
+
+  const char data2[] = "longer for an \n overflow";
+
+  ASSERT_EQ(sizeof(data2), f->write(data2, sizeof(data2)));
+  // the buffer's initial contents should be " file\0"
+  // Writing data2 should cause two flushes, the first being when the buffer
+  // fills, flushing " file\0longer for a", then the second being when a newline
+  // is hit, flushing "n \n" and leaving " overflow\0" in the buffer.
+  EXPECT_EQ(f->get_pos(), size_t(27));
+  EXPECT_STREQ(f->get_str(), data);
+  EXPECT_STREQ(f->get_str() + sizeof(data), "longer for an \n");
+  ASSERT_EQ(f->flush(), 0);
+  EXPECT_STREQ(f->get_str() + sizeof(data), data2);
+
+  ASSERT_EQ(f->close(), 0);
+}
+
+TEST(LlvmLibcFileTest, WriteUnbuffered) {
+  const char data[] = "written immediately";
+  constexpr size_t FILE_BUFFER_SIZE = (sizeof(data) / 2) + 1;
+  char file_buffer[FILE_BUFFER_SIZE];
+  StringFile *f = new_string_file(file_buffer, FILE_BUFFER_SIZE,
+                                  __llvm_libc::File::UNBUFFERED, false, "w");
+
+  ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
+  EXPECT_EQ(f->get_pos(),
+            sizeof(data)); // no buffering means this is written immediately.
+  EXPECT_STREQ(f->get_str(), data);
+
+  ASSERT_EQ(f->close(), 0);
+}
+
 TEST(LlvmLibcFileTest, ReadOnly) {
   const char initial_content[] = "1234567890987654321";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
   char file_buffer[FILE_BUFFER_SIZE];
-  StringFile *f = new_string_file(file_buffer, FILE_BUFFER_SIZE, 0, false, "r");
+  StringFile *f =
+      new_string_file(file_buffer, FILE_BUFFER_SIZE,
+                      __llvm_libc::File::FULLY_BUFFERED, false, "r");
   f->reset_and_fill(initial_content, sizeof(initial_content));
 
   constexpr size_t READ_SIZE = sizeof(initial_content) / 2;
   char read_data[READ_SIZE];
   ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));
   EXPECT_FALSE(f->iseof());
   // Reading less than file buffer worth will still read one
   // full buffer worth of data.
TEST(LlvmLibcFileTest, ReadOnly) {
 
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, ReadSeekCurAndRead) {
   const char initial_content[] = "1234567890987654321";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
   char file_buffer[FILE_BUFFER_SIZE];
-  StringFile *f = new_string_file(file_buffer, FILE_BUFFER_SIZE, 0, false, "r");
+  StringFile *f =
+      new_string_file(file_buffer, FILE_BUFFER_SIZE,
+                      __llvm_libc::File::FULLY_BUFFERED, false, "r");
   f->reset_and_fill(initial_content, sizeof(initial_content));
 
   constexpr size_t READ_SIZE = 5;
   char data[READ_SIZE];
   data[READ_SIZE - 1] = '\0';
   ASSERT_EQ(f->read(data, READ_SIZE - 1), READ_SIZE - 1);
   ASSERT_STREQ(data, "1234");
   ASSERT_EQ(f->seek(5, SEEK_CUR), 0);
   ASSERT_EQ(f->read(data, READ_SIZE - 1), READ_SIZE - 1);
   ASSERT_STREQ(data, "0987");
   ASSERT_EQ(f->seek(-5, SEEK_CUR), 0);
   ASSERT_EQ(f->read(data, READ_SIZE - 1), READ_SIZE - 1);
   ASSERT_STREQ(data, "9098");
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, AppendOnly) {
   const char initial_content[] = "1234567890987654321";
   const char write_data[] = "append";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(write_data) * 3 / 2;
   char file_buffer[FILE_BUFFER_SIZE];
-  StringFile *f = new_string_file(file_buffer, FILE_BUFFER_SIZE, 0, false, "a");
+  StringFile *f =
+      new_string_file(file_buffer, FILE_BUFFER_SIZE,
+                      __llvm_libc::File::FULLY_BUFFERED, false, "a");
   f->reset_and_fill(initial_content, sizeof(initial_content));
 
   constexpr size_t READ_SIZE = 5;
   char read_data[READ_SIZE];
   // This is not a readable file.
   ASSERT_EQ(f->read(read_data, READ_SIZE), size_t(0));
   EXPECT_TRUE(f->error());
   EXPECT_NE(errno, 0);
TEST(LlvmLibcFileTest, AppendOnly) {
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, WriteUpdate) {
   const char data[] = "hello, file";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
-      new_string_file(file_buffer, FILE_BUFFER_SIZE, 0, false, "w+");
+      new_string_file(file_buffer, FILE_BUFFER_SIZE,
+                      __llvm_libc::File::FULLY_BUFFERED, false, "w+");
 
   ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
   EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
 
   ASSERT_EQ(f->seek(0, SEEK_SET), 0);
 
   // Seek flushes the stream buffer so we can read the previously written data.
   char read_data[sizeof(data)];
   ASSERT_EQ(f->read(read_data, sizeof(data)), sizeof(data));
   EXPECT_STREQ(read_data, data);
 
   ASSERT_EQ(f->close(), 0);
 }
 
 TEST(LlvmLibcFileTest, ReadUpdate) {
   const char initial_content[] = "1234567890987654321";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(initial_content);
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
-      new_string_file(file_buffer, FILE_BUFFER_SIZE, 0, false, "r+");
+      new_string_file(file_buffer, FILE_BUFFER_SIZE,
+                      __llvm_libc::File::FULLY_BUFFERED, false, "r+");
   f->reset_and_fill(initial_content, sizeof(initial_content));
 
   constexpr size_t READ_SIZE = sizeof(initial_content) / 2;
   char read_data[READ_SIZE];
   ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));
   EXPECT_FALSE(f->iseof());
   // Reading less than file buffer worth will still read one
   // full buffer worth of data.

 }
 
 TEST(LlvmLibcFileTest, AppendUpdate) {
   const char initial_content[] = "1234567890987654321";
   const char data[] = "hello, file";
   constexpr size_t FILE_BUFFER_SIZE = sizeof(data) * 3 / 2;
   char file_buffer[FILE_BUFFER_SIZE];
   StringFile *f =
-      new_string_file(file_buffer, FILE_BUFFER_SIZE, 0, false, "a+");
+      new_string_file(file_buffer, FILE_BUFFER_SIZE,
+                      __llvm_libc::File::FULLY_BUFFERED, false, "a+");
   f->reset_and_fill(initial_content, sizeof(initial_content));
 
   ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
   EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
   ASSERT_EQ(f->flush(), 0);
   // The flush should write |data| to the endof the file.
   EXPECT_EQ(f->get_pos(), sizeof(data) + sizeof(initial_content));
 
TEST(LlvmLibcFileTest, AppendUpdate) {
   ASSERT_EQ(f->seek(0, SEEK_SET), 0);
   constexpr size_t READ_SIZE = 10;
   char read_data[READ_SIZE];
   ASSERT_EQ(READ_SIZE, f->read(read_data, READ_SIZE));
   MemoryView src4(initial_content, READ_SIZE), dst4(read_data, READ_SIZE);
   EXPECT_MEM_EQ(src4, dst4);
 
   ASSERT_EQ(f->close(), 0);
 }