blob: a2edaeeb388329f8a87457588e44abc79cf54a07 [file] [edit]
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
///
/// \file
/// Unittests for getdelim.
///
//===----------------------------------------------------------------------===//
#include "hdr/errno_macros.h"
#include "hdr/func/free.h"
#include "hdr/func/malloc.h"
#include "hdr/stdio_macros.h"
#include "hdr/types/FILE.h"
#include "hdr/types/size_t.h"
#include "hdr/types/ssize_t.h"
#include "src/__support/CPP/scope.h"
#include "src/__support/CPP/string_view.h"
#include "src/__support/libc_errno.h"
#include "src/stdio/clearerr.h"
#include "src/stdio/fclose.h"
#include "src/stdio/feof.h"
#include "src/stdio/ferror.h"
#include "src/stdio/fmemopen.h"
#include "src/stdio/fopen.h"
#include "src/stdio/fseek.h"
#include "src/stdio/fwrite.h"
#include "src/stdio/getdelim.h"
#include "src/stdio/remove.h"
#include "src/stdio/ungetc.h"
#include "src/wchar/fwide.h"
#include "test/UnitTest/ErrnoCheckingTest.h"
#include "test/UnitTest/ErrnoSetterMatcher.h"
#include "test/UnitTest/Test.h"
using LIBC_NAMESPACE::cpp::scope_exit;
using LIBC_NAMESPACE::cpp::string_view;
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Fails;
using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
using LlvmLibcGetdelimTest = LIBC_NAMESPACE::testing::ErrnoCheckingTest;
TEST_F(LlvmLibcGetdelimTest, AllocatesWhenLineptrIsNull) {
char content[] = "hello world;";
::FILE *stream = LIBC_NAMESPACE::fmemopen(content, sizeof(content) - 1, "r");
ASSERT_NE(stream, nullptr);
scope_exit close_stream(
[&] { ASSERT_THAT(LIBC_NAMESPACE::fclose(stream), Succeeds(0)); });
char *line = nullptr;
size_t cap = 0;
scope_exit free_line([&] { ::free(line); });
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream),
Succeeds(ssize_t(12)));
ASSERT_NE(line, nullptr);
EXPECT_GE(cap, size_t(13));
EXPECT_STREQ(line, "hello world;");
EXPECT_EQ(LIBC_NAMESPACE::feof(stream), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(stream), 0);
ASSERT_EQ(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream), ssize_t(-1));
EXPECT_NE(LIBC_NAMESPACE::feof(stream), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(stream), 0);
}
TEST_F(LlvmLibcGetdelimTest, NullLineptrIgnoresNonZeroCapacity) {
char content[] = "short item;";
::FILE *stream = LIBC_NAMESPACE::fmemopen(content, sizeof(content) - 1, "r");
ASSERT_NE(stream, nullptr);
scope_exit close_stream(
[&] { ASSERT_THAT(LIBC_NAMESPACE::fclose(stream), Succeeds(0)); });
char *line = nullptr;
size_t cap = 1024;
scope_exit free_line([&] { ::free(line); });
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream),
Succeeds(ssize_t(11)));
ASSERT_NE(line, nullptr);
EXPECT_GE(cap, size_t(12));
EXPECT_STREQ(line, "short item;");
}
TEST_F(LlvmLibcGetdelimTest, ReusesSufficientCallerBuffer) {
char content[] = "fits in buffer;";
::FILE *stream = LIBC_NAMESPACE::fmemopen(content, sizeof(content) - 1, "r");
ASSERT_NE(stream, nullptr);
scope_exit close_stream(
[&] { ASSERT_THAT(LIBC_NAMESPACE::fclose(stream), Succeeds(0)); });
size_t cap = 64;
char *line = static_cast<char *>(::malloc(cap));
ASSERT_NE(line, nullptr);
scope_exit free_line([&] { ::free(line); });
char *original_ptr = line;
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream),
Succeeds(ssize_t(15)));
EXPECT_EQ(line, original_ptr);
EXPECT_EQ(cap, size_t(64));
EXPECT_STREQ(line, "fits in buffer;");
}
TEST_F(LlvmLibcGetdelimTest, GrowsSmallAndZeroSizedCallerBuffers) {
constexpr char CHARS[] = "pqrs789_+-=";
constexpr size_t LEN = 300;
char content[LEN];
for (size_t i = 0; i < LEN - 1; ++i)
content[i] = CHARS[i % (sizeof(CHARS) - 1)];
content[LEN - 1] = ';';
// 1-byte malloc'd buffer (needs space for char + NUL immediately).
{
::FILE *stream = LIBC_NAMESPACE::fmemopen(content, LEN, "r");
ASSERT_NE(stream, nullptr);
scope_exit close_stream(
[&] { ASSERT_THAT(LIBC_NAMESPACE::fclose(stream), Succeeds(0)); });
size_t cap = 1;
char *line = static_cast<char *>(::malloc(cap));
ASSERT_NE(line, nullptr);
scope_exit free_line([&] { ::free(line); });
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream),
Succeeds(ssize_t(LEN)));
ASSERT_NE(line, nullptr);
EXPECT_GE(cap, LEN + 1);
EXPECT_EQ(string_view(line, LEN), string_view(content, LEN));
EXPECT_EQ(line[LEN], '\0');
}
// Non-null malloc(0) pointer with *n == 0.
{
::FILE *stream = LIBC_NAMESPACE::fmemopen(content, LEN, "r");
ASSERT_NE(stream, nullptr);
scope_exit close_stream(
[&] { ASSERT_THAT(LIBC_NAMESPACE::fclose(stream), Succeeds(0)); });
size_t cap = 0;
char *line = static_cast<char *>(::malloc(0));
scope_exit free_line([&] { ::free(line); });
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream),
Succeeds(ssize_t(LEN)));
ASSERT_NE(line, nullptr);
EXPECT_GE(cap, LEN + 1);
EXPECT_EQ(string_view(line, LEN), string_view(content, LEN));
EXPECT_EQ(line[LEN], '\0');
}
}
TEST_F(LlvmLibcGetdelimTest, CustomDelimiterAndNoTrailingDelimiter) {
char content[] = "ab;\ncd\0e;;tail\n";
::FILE *stream = LIBC_NAMESPACE::fmemopen(content, sizeof(content) - 1, "r");
ASSERT_NE(stream, nullptr);
scope_exit close_stream(
[&] { ASSERT_THAT(LIBC_NAMESPACE::fclose(stream), Succeeds(0)); });
char *line = nullptr;
size_t cap = 0;
scope_exit free_line([&] { ::free(line); });
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream),
Succeeds(ssize_t(3)));
EXPECT_STREQ(line, "ab;");
EXPECT_GT(cap, size_t(3));
// The newline is not a delimiter here, and the embedded null byte is
// counted in the return value.
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream),
Succeeds(ssize_t(6)));
EXPECT_EQ(string_view(line, 6), string_view("\ncd\0e;", 6));
EXPECT_EQ(line[6], '\0');
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream),
Succeeds(ssize_t(1)));
EXPECT_STREQ(line, ";");
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream),
Succeeds(ssize_t(5)));
EXPECT_STREQ(line, "tail\n");
EXPECT_NE(LIBC_NAMESPACE::feof(stream), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(stream), 0);
ASSERT_EQ(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream), ssize_t(-1));
EXPECT_NE(LIBC_NAMESPACE::feof(stream), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(stream), 0);
}
TEST_F(LlvmLibcGetdelimTest, NullByteDelimiter) {
char content[] = "ab\0cd";
::FILE *stream = LIBC_NAMESPACE::fmemopen(content, sizeof(content) - 1, "r");
ASSERT_NE(stream, nullptr);
scope_exit close_stream(
[&] { ASSERT_THAT(LIBC_NAMESPACE::fclose(stream), Succeeds(0)); });
char *line = nullptr;
size_t cap = 0;
scope_exit free_line([&] { ::free(line); });
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, '\0', stream),
Succeeds(ssize_t(3)));
EXPECT_EQ(string_view(line, 3), string_view("ab\0", 3));
EXPECT_EQ(line[3], '\0');
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, '\0', stream),
Succeeds(ssize_t(2)));
EXPECT_STREQ(line, "cd");
EXPECT_NE(LIBC_NAMESPACE::feof(stream), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(stream), 0);
ASSERT_EQ(LIBC_NAMESPACE::getdelim(&line, &cap, '\0', stream), ssize_t(-1));
EXPECT_NE(LIBC_NAMESPACE::feof(stream), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(stream), 0);
}
TEST_F(LlvmLibcGetdelimTest, SwitchingDelimitersAcrossCalls) {
char content[] = "key:val\nzero\0rest";
::FILE *stream = LIBC_NAMESPACE::fmemopen(content, sizeof(content) - 1, "r");
ASSERT_NE(stream, nullptr);
scope_exit close_stream(
[&] { ASSERT_THAT(LIBC_NAMESPACE::fclose(stream), Succeeds(0)); });
char *line = nullptr;
size_t cap = 0;
scope_exit free_line([&] { ::free(line); });
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ':', stream),
Succeeds(ssize_t(4)));
EXPECT_STREQ(line, "key:");
char *allocated = line;
size_t allocated_cap = cap;
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, '\n', stream),
Succeeds(ssize_t(4)));
EXPECT_STREQ(line, "val\n");
EXPECT_EQ(line, allocated);
EXPECT_EQ(cap, allocated_cap);
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, '\0', stream),
Succeeds(ssize_t(5)));
EXPECT_EQ(string_view(line, 5), string_view("zero\0", 5));
EXPECT_EQ(line[5], '\0');
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', stream),
Succeeds(ssize_t(4)));
EXPECT_STREQ(line, "rest");
EXPECT_NE(LIBC_NAMESPACE::feof(stream), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(stream), 0);
}
TEST_F(LlvmLibcGetdelimTest, EmptyFilePreservesErrnoOnEof) {
constexpr char FILENAME[] = "getdelim_empty.test";
auto FILEPATH = libc_make_test_file_path(FILENAME);
::FILE *file = LIBC_NAMESPACE::fopen(FILEPATH, "w+");
ASSERT_NE(file, nullptr);
scope_exit close_file([&] {
ASSERT_THAT(LIBC_NAMESPACE::fclose(file), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::remove(FILEPATH), Succeeds(0));
});
char *line = nullptr;
size_t cap = 0;
scope_exit free_line([&] { ::free(line); });
libc_errno = 42;
ASSERT_EQ(LIBC_NAMESPACE::getdelim(&line, &cap, ';', file), ssize_t(-1));
ASSERT_ERRNO_EQ(42);
EXPECT_NE(LIBC_NAMESPACE::feof(file), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(file), 0);
}
TEST_F(LlvmLibcGetdelimTest, EmbeddedNullBytesAndHighBitBytes) {
constexpr char FILENAME[] = "getdelim_binary.test";
auto FILEPATH = libc_make_test_file_path(FILENAME);
::FILE *file = LIBC_NAMESPACE::fopen(FILEPATH, "w+");
ASSERT_NE(file, nullptr);
scope_exit close_file([&] {
ASSERT_THAT(LIBC_NAMESPACE::fclose(file), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::remove(FILEPATH), Succeeds(0));
});
constexpr char DATA[] = "ab\0cd\xff"
"ef;\0tail";
constexpr size_t DATA_LEN = sizeof(DATA) - 1;
ASSERT_THAT(LIBC_NAMESPACE::fwrite(DATA, 1, DATA_LEN, file),
Succeeds(DATA_LEN));
ASSERT_THAT(LIBC_NAMESPACE::fseek(file, 0, SEEK_SET), Succeeds(0));
char *line = nullptr;
size_t cap = 0;
scope_exit free_line([&] { ::free(line); });
// Byte 0xFF in input must not be confused with EOF.
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', file),
Succeeds(ssize_t(9)));
EXPECT_EQ(string_view(line, 9), string_view("ab\0cd\xff"
"ef;",
9));
EXPECT_EQ(line[9], '\0');
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', file),
Succeeds(ssize_t(5)));
EXPECT_EQ(string_view(line, 5), string_view("\0tail", 5));
EXPECT_EQ(line[5], '\0');
// Byte 0xFF passed as an unsigned char value works as a delimiter.
ASSERT_THAT(LIBC_NAMESPACE::fseek(file, 0, SEEK_SET), Succeeds(0));
const int ff_delim = static_cast<int>(static_cast<unsigned char>('\xff'));
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ff_delim, file),
Succeeds(ssize_t(6)));
EXPECT_EQ(string_view(line, 6), string_view("ab\0cd\xff", 6));
EXPECT_EQ(line[6], '\0');
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ff_delim, file),
Succeeds(ssize_t(8)));
EXPECT_EQ(string_view(line, 8), string_view("ef;\0tail", 8));
EXPECT_EQ(line[8], '\0');
EXPECT_NE(LIBC_NAMESPACE::feof(file), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(file), 0);
}
TEST_F(LlvmLibcGetdelimTest, LongRecordsFromFile) {
constexpr char FILENAME[] = "getdelim_long.test";
auto FILEPATH = libc_make_test_file_path(FILENAME);
constexpr char CHARS[] = "abcXYZ0123_!@#";
constexpr size_t REC1_LEN = 2500;
char expected1[REC1_LEN + 1];
for (size_t i = 0; i < REC1_LEN - 1; ++i)
expected1[i] = CHARS[i % (sizeof(CHARS) - 1)];
expected1[REC1_LEN - 1] = ';';
expected1[REC1_LEN] = '\0';
constexpr char EXPECTED2[] = "trailing record without delimiter\n";
constexpr size_t REC2_LEN = sizeof(EXPECTED2) - 1;
::FILE *writer = LIBC_NAMESPACE::fopen(FILEPATH, "w");
ASSERT_NE(writer, nullptr);
scope_exit remove_file(
[&] { ASSERT_THAT(LIBC_NAMESPACE::remove(FILEPATH), Succeeds(0)); });
{
scope_exit close_writer(
[&] { ASSERT_THAT(LIBC_NAMESPACE::fclose(writer), Succeeds(0)); });
ASSERT_THAT(LIBC_NAMESPACE::fwrite(expected1, 1, REC1_LEN, writer),
Succeeds(REC1_LEN));
ASSERT_THAT(LIBC_NAMESPACE::fwrite(EXPECTED2, 1, REC2_LEN, writer),
Succeeds(REC2_LEN));
}
::FILE *reader = LIBC_NAMESPACE::fopen(FILEPATH, "r");
ASSERT_NE(reader, nullptr);
scope_exit close_reader(
[&] { ASSERT_THAT(LIBC_NAMESPACE::fclose(reader), Succeeds(0)); });
char *line = nullptr;
size_t cap = 0;
scope_exit free_line([&] { ::free(line); });
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', reader),
Succeeds(ssize_t(REC1_LEN)));
ASSERT_NE(line, nullptr);
EXPECT_GE(cap, REC1_LEN + 1);
EXPECT_STREQ(line, expected1);
EXPECT_EQ(LIBC_NAMESPACE::feof(reader), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(reader), 0);
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', reader),
Succeeds(ssize_t(REC2_LEN)));
EXPECT_STREQ(line, EXPECTED2);
EXPECT_NE(LIBC_NAMESPACE::feof(reader), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(reader), 0);
ASSERT_EQ(LIBC_NAMESPACE::getdelim(&line, &cap, ';', reader), ssize_t(-1));
EXPECT_NE(LIBC_NAMESPACE::feof(reader), 0);
EXPECT_EQ(LIBC_NAMESPACE::ferror(reader), 0);
}
TEST_F(LlvmLibcGetdelimTest, StickyEofClearedByFseekAndUngetc) {
constexpr char FILENAME[] = "getdelim_sticky_eof.test";
auto FILEPATH = libc_make_test_file_path(FILENAME);
::FILE *reader = LIBC_NAMESPACE::fopen(FILEPATH, "w+");
ASSERT_NE(reader, nullptr);
::FILE *appender = LIBC_NAMESPACE::fopen(FILEPATH, "a");
ASSERT_NE(appender, nullptr);
scope_exit close_files([&] {
if (appender != nullptr)
ASSERT_THAT(LIBC_NAMESPACE::fclose(appender), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::fclose(reader), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::remove(FILEPATH), Succeeds(0));
});
char *line = nullptr;
size_t cap = 0;
scope_exit free_line([&] { ::free(line); });
// Hit EOF on empty file.
ASSERT_EQ(LIBC_NAMESPACE::getdelim(&line, &cap, ';', reader), ssize_t(-1));
ASSERT_NE(LIBC_NAMESPACE::feof(reader), 0);
// Append new data externally; sticky EOF on reader must still return -1.
constexpr char MORE[] = "appended;";
ASSERT_THAT(LIBC_NAMESPACE::fwrite(MORE, 1, sizeof(MORE) - 1, appender),
Succeeds(sizeof(MORE) - 1));
ASSERT_THAT(LIBC_NAMESPACE::fclose(appender), Succeeds(0));
appender = nullptr;
ASSERT_EQ(LIBC_NAMESPACE::getdelim(&line, &cap, ';', reader), ssize_t(-1));
EXPECT_NE(LIBC_NAMESPACE::feof(reader), 0);
// Positioning operation clears sticky EOF and allows reading appended record.
ASSERT_THAT(LIBC_NAMESPACE::fseek(reader, 0, SEEK_CUR), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', reader),
Succeeds(ssize_t(9)));
EXPECT_STREQ(line, "appended;");
// Hit EOF again, then push back a character with ungetc.
ASSERT_EQ(LIBC_NAMESPACE::getdelim(&line, &cap, ';', reader), ssize_t(-1));
ASSERT_NE(LIBC_NAMESPACE::feof(reader), 0);
ASSERT_EQ(LIBC_NAMESPACE::ungetc('Z', reader), int('Z'));
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', reader),
Succeeds(ssize_t(1)));
EXPECT_STREQ(line, "Z");
}
TEST_F(LlvmLibcGetdelimTest, InvalidArgumentsSetErrnoAndStreamError) {
char content[] = "abc;";
::FILE *stream = LIBC_NAMESPACE::fmemopen(content, sizeof(content) - 1, "r");
ASSERT_NE(stream, nullptr);
scope_exit close_stream(
[&] { ASSERT_THAT(LIBC_NAMESPACE::fclose(stream), Succeeds(0)); });
size_t cap = 0;
ASSERT_THAT(LIBC_NAMESPACE::getdelim(nullptr, &cap, ';', stream),
Fails(EINVAL, ssize_t(-1)));
EXPECT_NE(LIBC_NAMESPACE::ferror(stream), 0);
LIBC_NAMESPACE::clearerr(stream);
char *line = nullptr;
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, nullptr, ';', stream),
Fails(EINVAL, ssize_t(-1)));
EXPECT_NE(LIBC_NAMESPACE::ferror(stream), 0);
EXPECT_EQ(line, nullptr);
}
TEST_F(LlvmLibcGetdelimTest, WriteOnlyStreamFailsWithEbadf) {
constexpr char FILENAME[] = "getdelim_write_only.test";
auto FILEPATH = libc_make_test_file_path(FILENAME);
::FILE *file = LIBC_NAMESPACE::fopen(FILEPATH, "w");
ASSERT_NE(file, nullptr);
scope_exit close_file([&] {
ASSERT_THAT(LIBC_NAMESPACE::fclose(file), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::remove(FILEPATH), Succeeds(0));
});
char *line = nullptr;
size_t cap = 0;
scope_exit free_line([&] { ::free(line); });
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', file),
Fails(EBADF, ssize_t(-1)));
EXPECT_NE(LIBC_NAMESPACE::ferror(file), 0);
EXPECT_EQ(line, nullptr);
}
TEST_F(LlvmLibcGetdelimTest, WideOrientedStreamFailsWithEinval) {
constexpr char FILENAME[] = "getdelim_wide.test";
auto FILEPATH = libc_make_test_file_path(FILENAME);
::FILE *file = LIBC_NAMESPACE::fopen(FILEPATH, "w+");
ASSERT_NE(file, nullptr);
scope_exit close_file([&] {
ASSERT_THAT(LIBC_NAMESPACE::fclose(file), Succeeds(0));
ASSERT_THAT(LIBC_NAMESPACE::remove(FILEPATH), Succeeds(0));
});
ASSERT_GT(LIBC_NAMESPACE::fwide(file, 1), 0);
char *line = nullptr;
size_t cap = 0;
scope_exit free_line([&] { ::free(line); });
ASSERT_THAT(LIBC_NAMESPACE::getdelim(&line, &cap, ';', file),
Fails(EINVAL, ssize_t(-1)));
EXPECT_NE(LIBC_NAMESPACE::ferror(file), 0);
EXPECT_EQ(line, nullptr);
}
#if defined(LIBC_ADD_NULL_CHECKS)
TEST_F(LlvmLibcGetdelimTest, NullStreamCrash) {
EXPECT_DEATH(
[] {
char *line = nullptr;
size_t cap = 0;
LIBC_NAMESPACE::getdelim(&line, &cap, ';', nullptr);
},
WITH_SIGNAL(-1));
}
#endif // LIBC_ADD_NULL_CHECKS