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 <dirent.h>
20 #include <errno.h>
21 #include <fcntl.h>
22 #include <limits.h>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25 #include <unistd.h>
26
27 #include <algorithm>
28 #include <set>
29 #include <string>
30
CheckProcSelf(std::set<std::string> & names)31 static void CheckProcSelf(std::set<std::string>& names) {
32 // We have a good idea of what should be in /proc/self.
33 ASSERT_TRUE(names.find(".") != names.end());
34 ASSERT_TRUE(names.find("..") != names.end());
35 ASSERT_TRUE(names.find("cmdline") != names.end());
36 ASSERT_TRUE(names.find("fd") != names.end());
37 ASSERT_TRUE(names.find("stat") != names.end());
38 }
39
TEST(dirent,scandir)40 TEST(dirent, scandir) {
41 // Get everything from /proc/self...
42 dirent** entries;
43 int entry_count = scandir("/proc/self", &entries, NULL, alphasort);
44 ASSERT_GE(entry_count, 0);
45
46 // Turn the directory entries into a set and vector of the names.
47 std::set<std::string> name_set;
48 std::vector<std::string> unsorted_name_list;
49 for (size_t i = 0; i < static_cast<size_t>(entry_count); ++i) {
50 name_set.insert(entries[i]->d_name);
51 unsorted_name_list.push_back(entries[i]->d_name);
52 free(entries[i]);
53 }
54 free(entries);
55
56 // No duplicates.
57 ASSERT_EQ(name_set.size(), unsorted_name_list.size());
58
59 // All entries sorted.
60 std::vector<std::string> sorted_name_list(unsorted_name_list);
61 std::sort(sorted_name_list.begin(), sorted_name_list.end());
62 ASSERT_EQ(sorted_name_list, unsorted_name_list);
63
64 CheckProcSelf(name_set);
65 }
66
TEST(dirent,fdopendir_invalid)67 TEST(dirent, fdopendir_invalid) {
68 ASSERT_TRUE(fdopendir(-1) == NULL);
69 ASSERT_EQ(EBADF, errno);
70
71 int fd = open("/dev/null", O_RDONLY);
72 ASSERT_NE(fd, -1);
73 ASSERT_TRUE(fdopendir(fd) == NULL);
74 ASSERT_EQ(ENOTDIR, errno);
75 close(fd);
76 }
77
TEST(dirent,fdopendir)78 TEST(dirent, fdopendir) {
79 int fd = open("/proc/self", O_RDONLY);
80 DIR* d = fdopendir(fd);
81 ASSERT_TRUE(d != NULL);
82 dirent* e = readdir(d);
83 ASSERT_STREQ(e->d_name, ".");
84 ASSERT_EQ(closedir(d), 0);
85
86 // fdopendir(3) took ownership, so closedir(3) closed our fd.
87 ASSERT_EQ(close(fd), -1);
88 ASSERT_EQ(EBADF, errno);
89 }
90
TEST(dirent,opendir_invalid)91 TEST(dirent, opendir_invalid) {
92 ASSERT_TRUE(opendir("/does/not/exist") == NULL);
93 ASSERT_EQ(ENOENT, errno);
94
95 ASSERT_TRUE(opendir("/dev/null") == NULL);
96 ASSERT_EQ(ENOTDIR, errno);
97 }
98
TEST(dirent,opendir)99 TEST(dirent, opendir) {
100 DIR* d = opendir("/proc/self");
101 ASSERT_TRUE(d != NULL);
102 dirent* e = readdir(d);
103 ASSERT_STREQ(e->d_name, ".");
104 ASSERT_EQ(closedir(d), 0);
105 }
106
TEST(dirent,closedir_invalid)107 TEST(dirent, closedir_invalid) {
108 DIR* d = NULL;
109 ASSERT_EQ(closedir(d), -1);
110 ASSERT_EQ(EINVAL, errno);
111 }
112
TEST(dirent,closedir)113 TEST(dirent, closedir) {
114 DIR* d = opendir("/proc/self");
115 ASSERT_TRUE(d != NULL);
116 ASSERT_EQ(closedir(d), 0);
117 }
118
TEST(dirent,readdir)119 TEST(dirent, readdir) {
120 DIR* d = opendir("/proc/self");
121 ASSERT_TRUE(d != NULL);
122 std::set<std::string> name_set;
123 errno = 0;
124 dirent* e;
125 while ((e = readdir(d)) != NULL) {
126 name_set.insert(e->d_name);
127 }
128 // Reading to the end of the directory is not an error.
129 // readdir(3) returns NULL, but leaves errno as 0.
130 ASSERT_EQ(0, errno);
131 ASSERT_EQ(closedir(d), 0);
132
133 CheckProcSelf(name_set);
134 }
135
TEST(dirent,readdir_r)136 TEST(dirent, readdir_r) {
137 DIR* d = opendir("/proc/self");
138 ASSERT_TRUE(d != NULL);
139 std::set<std::string> name_set;
140 errno = 0;
141 dirent storage;
142 dirent* e = NULL;
143 while (readdir_r(d, &storage, &e) == 0 && e != NULL) {
144 name_set.insert(e->d_name);
145 }
146 // Reading to the end of the directory is not an error.
147 // readdir_r(3) returns NULL, but leaves errno as 0.
148 ASSERT_EQ(0, errno);
149 ASSERT_EQ(closedir(d), 0);
150
151 CheckProcSelf(name_set);
152 }
153
TEST(dirent,rewinddir)154 TEST(dirent, rewinddir) {
155 DIR* d = opendir("/proc/self");
156 ASSERT_TRUE(d != NULL);
157
158 // Get all the names once...
159 std::vector<std::string> pass1;
160 dirent* e;
161 while ((e = readdir(d)) != NULL) {
162 pass1.push_back(e->d_name);
163 }
164
165 // ...rewind...
166 rewinddir(d);
167
168 // ...and get all the names again.
169 std::vector<std::string> pass2;
170 while ((e = readdir(d)) != NULL) {
171 pass2.push_back(e->d_name);
172 }
173
174 ASSERT_EQ(closedir(d), 0);
175
176 // We should have seen the same names in the same order both times.
177 ASSERT_EQ(pass1.size(), pass2.size());
178 for (size_t i = 0; i < pass1.size(); ++i) {
179 ASSERT_EQ(pass1[i], pass2[i]);
180 }
181 }
182