1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved. 2 * 3 * Permission is hereby granted, free of charge, to any person obtaining a copy 4 * of this software and associated documentation files (the "Software"), to 5 * deal in the Software without restriction, including without limitation the 6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 7 * sell copies of the Software, and to permit persons to whom the Software is 8 * furnished to do so, subject to the following conditions: 9 * 10 * The above copyright notice and this permission notice shall be included in 11 * all copies or substantial portions of the Software. 12 * 13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 19 * IN THE SOFTWARE. 20 */ 21 22 #include "uv.h" 23 #include "task.h" 24 25 #include <string.h> 26 27 #define FIXTURE "testfile" 28 29 static void timer_cb(uv_timer_t* handle); 30 static void close_cb(uv_handle_t* handle); 31 static void poll_cb(uv_fs_poll_t* handle, 32 int status, 33 const uv_stat_t* prev, 34 const uv_stat_t* curr); 35 36 static void poll_cb_fail(uv_fs_poll_t* handle, 37 int status, 38 const uv_stat_t* prev, 39 const uv_stat_t* curr); 40 static void poll_cb_noop(uv_fs_poll_t* handle, 41 int status, 42 const uv_stat_t* prev, 43 const uv_stat_t* curr); 44 45 static uv_fs_poll_t poll_handle; 46 static uv_timer_t timer_handle; 47 static uv_loop_t* loop; 48 49 static int poll_cb_called; 50 static int timer_cb_called; 51 static int close_cb_called; 52 53 54 static void touch_file(const char* path) { 55 static int count; 56 FILE* fp; 57 int i; 58 59 ASSERT((fp = fopen(FIXTURE, "w+"))); 60 61 /* Need to change the file size because the poller may not pick up 62 * sub-second mtime changes. 63 */ 64 i = ++count; 65 66 while (i--) 67 fputc('*', fp); 68 69 fclose(fp); 70 } 71 72 73 static void close_cb(uv_handle_t* handle) { 74 close_cb_called++; 75 } 76 77 78 static void timer_cb(uv_timer_t* handle) { 79 touch_file(FIXTURE); 80 timer_cb_called++; 81 } 82 83 84 static void poll_cb_fail(uv_fs_poll_t* handle, 85 int status, 86 const uv_stat_t* prev, 87 const uv_stat_t* curr) { 88 ASSERT(0 && "fail_cb called"); 89 } 90 91 static void poll_cb_noop(uv_fs_poll_t* handle, 92 int status, 93 const uv_stat_t* prev, 94 const uv_stat_t* curr) { 95 } 96 97 98 static void poll_cb(uv_fs_poll_t* handle, 99 int status, 100 const uv_stat_t* prev, 101 const uv_stat_t* curr) { 102 uv_stat_t zero_statbuf; 103 104 memset(&zero_statbuf, 0, sizeof(zero_statbuf)); 105 106 ASSERT_PTR_EQ(handle, &poll_handle); 107 ASSERT_EQ(1, uv_is_active((uv_handle_t*) handle)); 108 ASSERT_NOT_NULL(prev); 109 ASSERT_NOT_NULL(curr); 110 111 switch (poll_cb_called++) { 112 case 0: 113 ASSERT_EQ(status, UV_ENOENT); 114 ASSERT_OK(memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); 115 ASSERT_OK(memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); 116 touch_file(FIXTURE); 117 break; 118 119 case 1: 120 ASSERT_OK(status); 121 ASSERT_OK(memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); 122 ASSERT_NE(0, memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); 123 ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 20, 0)); 124 break; 125 126 case 2: 127 ASSERT_OK(status); 128 ASSERT_NE(0, memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); 129 ASSERT_NE(0, memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); 130 ASSERT_OK(uv_timer_start(&timer_handle, timer_cb, 200, 0)); 131 break; 132 133 case 3: 134 ASSERT_OK(status); 135 ASSERT_NE(0, memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); 136 ASSERT_NE(0, memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); 137 remove(FIXTURE); 138 break; 139 140 case 4: 141 ASSERT_EQ(status, UV_ENOENT); 142 ASSERT_NE(0, memcmp(prev, &zero_statbuf, sizeof(zero_statbuf))); 143 ASSERT_OK(memcmp(curr, &zero_statbuf, sizeof(zero_statbuf))); 144 uv_close((uv_handle_t*)handle, close_cb); 145 break; 146 147 default: 148 ASSERT(0); 149 } 150 } 151 152 153 TEST_IMPL(fs_poll) { 154 loop = uv_default_loop(); 155 156 remove(FIXTURE); 157 158 ASSERT_OK(uv_timer_init(loop, &timer_handle)); 159 ASSERT_OK(uv_fs_poll_init(loop, &poll_handle)); 160 ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb, FIXTURE, 100)); 161 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); 162 163 ASSERT_EQ(5, poll_cb_called); 164 ASSERT_EQ(2, timer_cb_called); 165 ASSERT_EQ(1, close_cb_called); 166 167 MAKE_VALGRIND_HAPPY(loop); 168 return 0; 169 } 170 171 172 TEST_IMPL(fs_poll_getpath) { 173 char buf[1024]; 174 size_t len; 175 loop = uv_default_loop(); 176 177 remove(FIXTURE); 178 179 ASSERT_OK(uv_fs_poll_init(loop, &poll_handle)); 180 len = sizeof buf; 181 ASSERT_EQ(UV_EINVAL, uv_fs_poll_getpath(&poll_handle, buf, &len)); 182 ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); 183 len = sizeof buf; 184 ASSERT_OK(uv_fs_poll_getpath(&poll_handle, buf, &len)); 185 ASSERT_NE(0, buf[len - 1]); 186 ASSERT_EQ(buf[len], '\0'); 187 ASSERT_OK(memcmp(buf, FIXTURE, len)); 188 189 uv_close((uv_handle_t*) &poll_handle, close_cb); 190 191 ASSERT_OK(uv_run(loop, UV_RUN_DEFAULT)); 192 193 ASSERT_EQ(1, close_cb_called); 194 195 MAKE_VALGRIND_HAPPY(loop); 196 return 0; 197 } 198 199 200 TEST_IMPL(fs_poll_close_request) { 201 uv_loop_t loop; 202 uv_fs_poll_t poll_handle; 203 204 remove(FIXTURE); 205 206 ASSERT_OK(uv_loop_init(&loop)); 207 208 ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle)); 209 ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); 210 uv_close((uv_handle_t*) &poll_handle, close_cb); 211 while (close_cb_called == 0) 212 uv_run(&loop, UV_RUN_ONCE); 213 ASSERT_EQ(1, close_cb_called); 214 215 MAKE_VALGRIND_HAPPY(&loop); 216 return 0; 217 } 218 219 TEST_IMPL(fs_poll_close_request_multi_start_stop) { 220 uv_loop_t loop; 221 uv_fs_poll_t poll_handle; 222 int i; 223 224 remove(FIXTURE); 225 226 ASSERT_OK(uv_loop_init(&loop)); 227 228 ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle)); 229 230 for (i = 0; i < 10; ++i) { 231 ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); 232 ASSERT_OK(uv_fs_poll_stop(&poll_handle)); 233 } 234 uv_close((uv_handle_t*) &poll_handle, close_cb); 235 while (close_cb_called == 0) 236 uv_run(&loop, UV_RUN_ONCE); 237 ASSERT_EQ(1, close_cb_called); 238 239 MAKE_VALGRIND_HAPPY(&loop); 240 return 0; 241 } 242 243 TEST_IMPL(fs_poll_close_request_multi_stop_start) { 244 uv_loop_t loop; 245 uv_fs_poll_t poll_handle; 246 int i; 247 248 remove(FIXTURE); 249 250 ASSERT_OK(uv_loop_init(&loop)); 251 252 ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle)); 253 254 for (i = 0; i < 10; ++i) { 255 ASSERT_OK(uv_fs_poll_stop(&poll_handle)); 256 ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_fail, FIXTURE, 100)); 257 } 258 uv_close((uv_handle_t*) &poll_handle, close_cb); 259 while (close_cb_called == 0) 260 uv_run(&loop, UV_RUN_ONCE); 261 ASSERT_EQ(1, close_cb_called); 262 263 MAKE_VALGRIND_HAPPY(&loop); 264 return 0; 265 } 266 267 TEST_IMPL(fs_poll_close_request_stop_when_active) { 268 /* Regression test for https://github.com/libuv/libuv/issues/2287. */ 269 uv_loop_t loop; 270 uv_fs_poll_t poll_handle; 271 272 remove(FIXTURE); 273 274 ASSERT_OK(uv_loop_init(&loop)); 275 276 /* Set up all handles. */ 277 ASSERT_OK(uv_fs_poll_init(&loop, &poll_handle)); 278 ASSERT_OK(uv_fs_poll_start(&poll_handle, poll_cb_noop, FIXTURE, 100)); 279 uv_run(&loop, UV_RUN_ONCE); 280 281 /* Close the timer handle, and do not crash. */ 282 ASSERT_OK(uv_fs_poll_stop(&poll_handle)); 283 uv_run(&loop, UV_RUN_ONCE); 284 285 /* Clean up after the test. */ 286 uv_close((uv_handle_t*) &poll_handle, close_cb); 287 uv_run(&loop, UV_RUN_ONCE); 288 ASSERT_EQ(1, close_cb_called); 289 290 MAKE_VALGRIND_HAPPY(&loop); 291 return 0; 292 } 293
Indexes created Sun Mar 01 05:31:48 UTC 2026