summaryrefslogtreecommitdiffstats
path: root/test/testfileinfo.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--test/testfileinfo.c263
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;
+}
+