diff options
Diffstat (limited to 'test/testfileinfo.c')
| -rw-r--r-- | test/testfileinfo.c | 263 |
1 files changed, 263 insertions, 0 deletions
diff --git a/test/testfileinfo.c b/test/testfileinfo.c new file mode 100644 index 0000000..ff08593 --- /dev/null +++ b/test/testfileinfo.c @@ -0,0 +1,263 @@ +/* Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "apr_file_io.h" +#include "apr_file_info.h" +#include "apr_strings.h" +#include "apr_errno.h" +#include "apr_general.h" +#include "apr_poll.h" +#include "apr_lib.h" +#include "testutil.h" + +#define FILENAME "data/file_datafile.txt" +#define NEWFILENAME "data/new_datafile.txt" +#define NEWFILEDATA "This is new text in a new file." + +static const struct view_fileinfo +{ + apr_int32_t bits; + char *description; +} vfi[] = { + {APR_FINFO_MTIME, "MTIME"}, + {APR_FINFO_CTIME, "CTIME"}, + {APR_FINFO_ATIME, "ATIME"}, + {APR_FINFO_SIZE, "SIZE"}, + {APR_FINFO_DEV, "DEV"}, + {APR_FINFO_INODE, "INODE"}, + {APR_FINFO_NLINK, "NLINK"}, + {APR_FINFO_TYPE, "TYPE"}, + {APR_FINFO_USER, "USER"}, + {APR_FINFO_GROUP, "GROUP"}, + {APR_FINFO_UPROT, "UPROT"}, + {APR_FINFO_GPROT, "GPROT"}, + {APR_FINFO_WPROT, "WPROT"}, + {0, NULL} +}; + +static void finfo_equal(abts_case *tc, apr_finfo_t *f1, apr_finfo_t *f2) +{ + /* Minimum supported flags across all platforms (APR_FINFO_MIN) */ + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo must return APR_FINFO_TYPE", + (f1->valid & f2->valid & APR_FINFO_TYPE)); + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in filetype", + f1->filetype == f2->filetype); + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo must return APR_FINFO_SIZE", + (f1->valid & f2->valid & APR_FINFO_SIZE)); + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in size", + f1->size == f2->size); + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo must return APR_FINFO_ATIME", + (f1->valid & f2->valid & APR_FINFO_ATIME)); + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in atime", + f1->atime == f2->atime); + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo must return APR_FINFO_MTIME", + (f1->valid & f2->valid & APR_FINFO_MTIME)); + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in mtime", + f1->mtime == f2->mtime); + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo must return APR_FINFO_CTIME", + (f1->valid & f2->valid & APR_FINFO_CTIME)); + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in ctime", + f1->ctime == f2->ctime); + + if (f1->valid & f2->valid & APR_FINFO_NAME) + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in name", + !strcmp(f1->name, f2->name)); + if (f1->fname && f2->fname) + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in fname", + !strcmp(f1->fname, f2->fname)); + + /* Additional supported flags not supported on all platforms */ + if (f1->valid & f2->valid & APR_FINFO_USER) + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in user", + !apr_uid_compare(f1->user, f2->user)); + if (f1->valid & f2->valid & APR_FINFO_GROUP) + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in group", + !apr_gid_compare(f1->group, f2->group)); + if (f1->valid & f2->valid & APR_FINFO_INODE) + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in inode", + f1->inode == f2->inode); + if (f1->valid & f2->valid & APR_FINFO_DEV) + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in device", + f1->device == f2->device); + if (f1->valid & f2->valid & APR_FINFO_NLINK) + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in nlink", + f1->nlink == f2->nlink); + if (f1->valid & f2->valid & APR_FINFO_CSIZE) + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in csize", + f1->csize == f2->csize); + if (f1->valid & f2->valid & APR_FINFO_PROT) + ABTS_ASSERT(tc, "apr_stat and apr_getfileinfo differ in protection", + f1->protection == f2->protection); +} + +static void test_info_get(abts_case *tc, void *data) +{ + apr_file_t *thefile; + apr_finfo_t finfo; + apr_status_t rv; + + rv = apr_file_open(&thefile, FILENAME, APR_FOPEN_READ, APR_OS_DEFAULT, p); + ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); + + rv = apr_file_info_get(&finfo, APR_FINFO_NORM, thefile); + if (APR_STATUS_IS_INCOMPLETE(rv)) { + char *str; + int i; + str = apr_pstrdup(p, "APR_INCOMPLETE: Missing "); + for (i = 0; vfi[i].bits; ++i) { + if (vfi[i].bits & ~finfo.valid) { + str = apr_pstrcat(p, str, vfi[i].description, " ", NULL); + } + } + ABTS_FAIL(tc, str); + } + ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); + apr_file_close(thefile); +} + +static void test_stat(abts_case *tc, void *data) +{ + apr_finfo_t finfo; + apr_status_t rv; + + rv = apr_stat(&finfo, FILENAME, APR_FINFO_NORM, p); + if (APR_STATUS_IS_INCOMPLETE(rv)) { + char *str; + int i; + str = apr_pstrdup(p, "APR_INCOMPLETE: Missing "); + for (i = 0; vfi[i].bits; ++i) { + if (vfi[i].bits & ~finfo.valid) { + str = apr_pstrcat(p, str, vfi[i].description, " ", NULL); + } + } + ABTS_FAIL(tc, str); + } + ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); +} + +static void test_stat_eq_finfo(abts_case *tc, void *data) +{ + apr_file_t *thefile; + apr_finfo_t finfo; + apr_finfo_t stat_finfo; + apr_status_t rv; + + rv = apr_file_open(&thefile, FILENAME, APR_FOPEN_READ, APR_OS_DEFAULT, p); + ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); + rv = apr_file_info_get(&finfo, APR_FINFO_NORM, thefile); + + /* Opening the file may have toggled the atime member (time last + * accessed), so fetch our apr_stat() after getting the fileinfo + * of the open file... + */ + rv = apr_stat(&stat_finfo, FILENAME, APR_FINFO_NORM, p); + ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); + + apr_file_close(thefile); + + finfo_equal(tc, &stat_finfo, &finfo); +} + +static void test_buffered_write_size(abts_case *tc, void *data) +{ + const apr_size_t data_len = strlen(NEWFILEDATA); + apr_file_t *thefile; + apr_finfo_t finfo; + apr_status_t rv; + apr_size_t bytes; + + rv = apr_file_open(&thefile, NEWFILENAME, + APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE + | APR_FOPEN_BUFFERED | APR_FOPEN_DELONCLOSE, + APR_OS_DEFAULT, p); + APR_ASSERT_SUCCESS(tc, "open file", rv); + + /* A funny thing happened to me the other day: I wrote something + * into a buffered file, then asked for its size using + * apr_file_info_get; and guess what? The size was 0! That's not a + * nice way to behave. + */ + bytes = data_len; + rv = apr_file_write(thefile, NEWFILEDATA, &bytes); + APR_ASSERT_SUCCESS(tc, "write file contents", rv); + ABTS_TRUE(tc, data_len == bytes); + + rv = apr_file_info_get(&finfo, APR_FINFO_SIZE, thefile); + APR_ASSERT_SUCCESS(tc, "get file size", rv); + ABTS_TRUE(tc, bytes == (apr_size_t) finfo.size); + apr_file_close(thefile); +} + +static void test_mtime_set(abts_case *tc, void *data) +{ + apr_file_t *thefile; + apr_finfo_t finfo; + apr_time_t epoch = 0; + apr_status_t rv; + + /* This test sort of depends on the system clock being at least + * marginally ccorrect; We'll be setting the modification time to + * the epoch. + */ + rv = apr_file_open(&thefile, NEWFILENAME, + APR_FOPEN_READ | APR_FOPEN_WRITE | APR_FOPEN_CREATE | APR_FOPEN_TRUNCATE + | APR_FOPEN_BUFFERED | APR_FOPEN_DELONCLOSE, + APR_OS_DEFAULT, p); + APR_ASSERT_SUCCESS(tc, "open file", rv); + + /* Check that the current mtime is not the epoch */ + rv = apr_stat(&finfo, NEWFILENAME, APR_FINFO_MTIME, p); + if (APR_STATUS_IS_INCOMPLETE(rv)) { + char *str; + int i; + str = apr_pstrdup(p, "APR_INCOMPLETE: Missing "); + for (i = 0; vfi[i].bits; ++i) { + if (vfi[i].bits & ~finfo.valid) { + str = apr_pstrcat(p, str, vfi[i].description, " ", NULL); + } + } + ABTS_FAIL(tc, str); + } + APR_ASSERT_SUCCESS(tc, "get initial mtime", rv); + ABTS_TRUE(tc, finfo.mtime != epoch); + + /* Reset the mtime to the epoch and verify the result. + * Note: we blindly assume that if the first apr_stat succeeded, + * the second one will, too. + */ + rv = apr_file_mtime_set(NEWFILENAME, epoch, p); + APR_ASSERT_SUCCESS(tc, "set mtime", rv); + + rv = apr_stat(&finfo, NEWFILENAME, APR_FINFO_MTIME, p); + APR_ASSERT_SUCCESS(tc, "get modified mtime", rv); + ABTS_TRUE(tc, finfo.mtime == epoch); + + apr_file_close(thefile); +} + +abts_suite *testfileinfo(abts_suite *suite) +{ + suite = ADD_SUITE(suite) + + abts_run_test(suite, test_info_get, NULL); + abts_run_test(suite, test_stat, NULL); + abts_run_test(suite, test_stat_eq_finfo, NULL); + abts_run_test(suite, test_buffered_write_size, NULL); + abts_run_test(suite, test_mtime_set, NULL); + + return suite; +} + |