stdio_test.cpp revision eac9eb462ed6f7fcfb791e7a08b4011fcca47829
1/* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include <gtest/gtest.h> 18 19#include <errno.h> 20#include <stdio.h> 21#include <sys/types.h> 22#include <sys/stat.h> 23#include <unistd.h> 24 25TEST(stdio, tmpfile_fileno_fprintf_rewind_fgets) { 26 FILE* fp = tmpfile(); 27 ASSERT_TRUE(fp != NULL); 28 29 int fd = fileno(fp); 30 ASSERT_NE(fd, -1); 31 32 struct stat sb; 33 int rc = fstat(fd, &sb); 34 ASSERT_NE(rc, -1); 35 ASSERT_EQ(sb.st_mode & 0777, 0600U); 36 37 rc = fprintf(fp, "hello\n"); 38 ASSERT_EQ(rc, 6); 39 40 rewind(fp); 41 42 char buf[16]; 43 char* s = fgets(buf, sizeof(buf), fp); 44 ASSERT_TRUE(s != NULL); 45 ASSERT_STREQ("hello\n", s); 46 47 fclose(fp); 48} 49 50TEST(stdio, getdelim) { 51 FILE* fp = tmpfile(); 52 ASSERT_TRUE(fp != NULL); 53 54 const char* line_written = "This is a test"; 55 int rc = fprintf(fp, "%s", line_written); 56 ASSERT_EQ(rc, static_cast<int>(strlen(line_written))); 57 58 rewind(fp); 59 60 char* word_read = NULL; 61 size_t allocated_length = 0; 62 63 const char* expected[] = { "This ", " ", "is ", "a ", "test" }; 64 for (size_t i = 0; i < 5; ++i) { 65 ASSERT_FALSE(feof(fp)); 66 ASSERT_EQ(getdelim(&word_read, &allocated_length, ' ', fp), static_cast<int>(strlen(expected[i]))); 67 ASSERT_GE(allocated_length, strlen(expected[i])); 68 ASSERT_STREQ(word_read, expected[i]); 69 } 70 // The last read should have set the end-of-file indicator for the stream. 71 ASSERT_TRUE(feof(fp)); 72 clearerr(fp); 73 74 // getdelim returns -1 but doesn't set errno if we're already at EOF. 75 // It should set the end-of-file indicator for the stream, though. 76 errno = 0; 77 ASSERT_EQ(getdelim(&word_read, &allocated_length, ' ', fp), -1); 78 ASSERT_EQ(errno, 0); 79 ASSERT_TRUE(feof(fp)); 80 81 free(word_read); 82 fclose(fp); 83} 84 85TEST(stdio, getdelim_invalid) { 86 FILE* fp = tmpfile(); 87 88 char* buffer = NULL; 89 size_t buffer_length = 0; 90 91 // The first argument can't be NULL. 92 errno = 0; 93 ASSERT_EQ(getdelim(NULL, &buffer_length, ' ', fp), -1); 94 ASSERT_EQ(errno, EINVAL); 95 96 // The second argument can't be NULL. 97 errno = 0; 98 ASSERT_EQ(getdelim(&buffer, NULL, ' ', fp), -1); 99 ASSERT_EQ(errno, EINVAL); 100 101 // The stream can't be closed. 102 fclose(fp); 103 errno = 0; 104 ASSERT_EQ(getdelim(&buffer, &buffer_length, ' ', fp), -1); 105 ASSERT_EQ(errno, EBADF); 106} 107 108TEST(stdio, getline) { 109 FILE* fp = tmpfile(); 110 ASSERT_TRUE(fp != NULL); 111 112 const char* line_written = "This is a test for getline\n"; 113 const size_t line_count = 5; 114 115 for (size_t i = 0; i < line_count; ++i) { 116 int rc = fprintf(fp, "%s", line_written); 117 ASSERT_EQ(rc, static_cast<int>(strlen(line_written))); 118 } 119 120 rewind(fp); 121 122 char* line_read = NULL; 123 size_t allocated_length = 0; 124 125 size_t read_line_count = 0; 126 ssize_t read_char_count; 127 while ((read_char_count = getline(&line_read, &allocated_length, fp)) != -1) { 128 ASSERT_EQ(read_char_count, static_cast<int>(strlen(line_written))); 129 ASSERT_GE(allocated_length, strlen(line_written)); 130 ASSERT_STREQ(line_read, line_written); 131 ++read_line_count; 132 } 133 ASSERT_EQ(read_line_count, line_count); 134 135 // The last read should have set the end-of-file indicator for the stream. 136 ASSERT_TRUE(feof(fp)); 137 clearerr(fp); 138 139 // getline returns -1 but doesn't set errno if we're already at EOF. 140 // It should set the end-of-file indicator for the stream, though. 141 errno = 0; 142 ASSERT_EQ(getline(&line_read, &allocated_length, fp), -1); 143 ASSERT_EQ(errno, 0); 144 ASSERT_TRUE(feof(fp)); 145 146 free(line_read); 147 fclose(fp); 148} 149 150TEST(stdio, getline_invalid) { 151 FILE* fp = tmpfile(); 152 153 char* buffer = NULL; 154 size_t buffer_length = 0; 155 156 // The first argument can't be NULL. 157 errno = 0; 158 ASSERT_EQ(getline(NULL, &buffer_length, fp), -1); 159 ASSERT_EQ(errno, EINVAL); 160 161 // The second argument can't be NULL. 162 errno = 0; 163 ASSERT_EQ(getline(&buffer, NULL, fp), -1); 164 ASSERT_EQ(errno, EINVAL); 165 166 // The stream can't be closed. 167 fclose(fp); 168 errno = 0; 169 ASSERT_EQ(getline(&buffer, &buffer_length, fp), -1); 170 ASSERT_EQ(errno, EBADF); 171} 172