[libc] Fix a bug in file write logic.

[sivachandra]

Summary

A bug when writing data much larger than the file buffer is fixed.

[michaelrj]

libc/src/__support/File/file.cpp

63

needs to be dataref[i+write_size]

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

135

add the following to prevent regressions:

MemoryView src1("hello, file\0hello, file", sizeof(data) * 2),
    dst1(f->get_str(), sizeof(data) * 2);
EXPECT_MEM_EQ(src1, dst1);

libc/src/__support/File/file.cpp

if (bytes_written <= used)
       return 0;
     // 2. Some of the bytes from |data| were written
     return bytes_written - used;
   }
 
   // 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) {
+  if (remaining <= bufsize) {
     // 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;

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

TEST(LlvmLibcFileTest, WriteOnly) {
   f->reset();
   ASSERT_EQ(f->get_pos(), size_t(0));
   ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
   EXPECT_EQ(f->get_pos(), size_t(0)); // Data is buffered in the file stream
   // The second write should trigger a buffer flush.
   ASSERT_EQ(sizeof(data), f->write(data, sizeof(data)));
   EXPECT_GE(f->get_pos(), size_t(0));
   ASSERT_EQ(f->flush(), 0);
   EXPECT_EQ(f->get_pos(), 2 * sizeof(data));
 
   char read_data[sizeof(data)];
   // This is not a readable file.
   EXPECT_EQ(f->read(read_data, sizeof(data)), size_t(0));
   EXPECT_TRUE(f->error());
   EXPECT_NE(errno, 0);
   errno = 0;
 
TEST(LlvmLibcFileTest, AppendUpdate) {
   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);
 }
+
+TEST(LlvmLibcFileTest, SmallBuffer) {
+  const char WRITE_DATA[] = "small buffer";
+  constexpr size_t WRITE_SIZE = sizeof(WRITE_DATA);
+  constexpr size_t FILE_BUFFER_SIZE = sizeof(WRITE_DATA) / 2 - 1;
+  char file_buffer[FILE_BUFFER_SIZE];
+  StringFile *f = new_string_file(file_buffer, FILE_BUFFER_SIZE, 0, false, "w");
+
+  ASSERT_EQ(WRITE_SIZE, f->write(WRITE_DATA, WRITE_SIZE));
+  // Since data much larger than the buffer is being written, all of it should
+  // be available in the file without a flush operation.
+  EXPECT_EQ(f->get_pos(), sizeof(WRITE_DATA));
+  ASSERT_STREQ(f->get_str(), WRITE_DATA);
+
+  ASSERT_EQ(f->close(), 0);
+}
+
+TEST(LlvmLibcFileTest, ZeroLengthBuffer) {
+  const char WRITE_DATA[] = "small buffer";
+  constexpr size_t WRITE_SIZE = sizeof(WRITE_DATA);
+  StringFile *f = new_string_file(nullptr, 0, 0, true, "w");
+
+  ASSERT_EQ(WRITE_SIZE, f->write(WRITE_DATA, WRITE_SIZE));
+  // Since there is no buffer space, all of the written data should
+  // be available in the file without a flush operation.
+  EXPECT_EQ(f->get_pos(), sizeof(WRITE_DATA));
+  ASSERT_STREQ(f->get_str(), WRITE_DATA);
+
+  ASSERT_EQ(f->close(), 0);
+}