copyfile_test/test_utils.h

   1 //
   2 //  test_utils.h
   3 //  copyfile_test
   4 //      Based on the test routines from the apfs project.
   5 //
   6
   7 #ifndef test_utils_h
   8 #define test_utils_h
   9
  10 #include <stdarg.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <string.h>
  14 #include <sys/errno.h>
  15
  16 #include "../copyfile.h"
  17
  18 #define BSIZE_B                                 128
  19 #define MAX_DISK_IMAGE_SIZE_MB  1024
  20
  21 #define DEFAULT_NAME_MOD                999
  22 #define DEFAULT_OPEN_FLAGS              O_CREAT|O_TRUNC|O_RDWR
  23 #define DEFAULT_OPEN_PERM               0666
  24 #define DEFAULT_MKDIR_PERM              0777
  25
  26 #define DISK_IMAGE_PATH                 "/tmp/copyfile_sparse.sparseimage"
  27 #define VOLUME_NAME                             "apfs_sparse"
  28 #define DEFAULT_FSTYPE                  "JHFS+"
  29 #define APFS_FSTYPE                             "apfs"
  30
  31 // We assume that we're mounted on /Volumes.
  32 #define MOUNT_PATH                              "/Volumes/" VOLUME_NAME
  33
  34 #define HDIUTIL_PATH                    "/usr/bin/hdiutil"
  35 #define DIFF_PATH                               "/usr/bin/diff"
  36
  37 // Test routine helpers.
  38 bool verify_st_flags(struct stat *sb, uint32_t flags_to_expect);
  39 bool verify_fd_contents(int orig_fd, off_t orig_pos, int copy_fd, off_t copy_pos, size_t length);
  40 bool verify_copy_contents(const char *orig_name, const char *copy_name);
  41 bool verify_copy_sizes(struct stat *orig_sb, struct stat *copy_sb, copyfile_state_t cpf_state,
  42                                            bool do_sparse, off_t src_start);
  43 int create_hole_in_fd(int fd, off_t offset, off_t length);
  44 void create_test_file_name(const char *dir, const char *postfix, int id, char *string_out);
  45
  46 // Our disk image test functions.
  47 void disk_image_create(const char *fstype, size_t size_in_mb);
  48 void disk_image_destroy(bool allow_failure);
  49
  50 // Assertion functions/macros for tests.
  51 static inline void
  52 __attribute__((format (printf, 3, 4)))
  53 __attribute__((noreturn))
  54 assert_fail_(const char *file, int line, const char *assertion, ...)
  55 {
  56         va_list args;
  57         va_start(args, assertion);
  58         char *msg;
  59         vasprintf(&msg, assertion, args);
  60         va_end(args);
  61         printf("\n%s:%u: error: %s\n", file, line, msg);
  62         exit(1);
  63 }
  64
  65 #define assert_fail(str, ...)                                           \
  66         assert_fail_(__FILE__, __LINE__, str, ## __VA_ARGS__)
  67
  68 #undef assert
  69 #define assert(condition)                                                                                       \
  70         do {                                                                                                                    \
  71                 if (!(condition))                                                                                       \
  72                         assert_fail_(__FILE__, __LINE__,                                                \
  73                                                 "assertion failed: %s", #condition);            \
  74         } while (0)
  75
  76 #define assert_with_errno_(condition, condition_str)                                    \
  77         do {                                                                                                                            \
  78                 if (!(condition))                                                                                               \
  79                         assert_fail_(__FILE__, __LINE__, "%s failed: %s",                       \
  80                                                 condition_str, strerror(errno));                                \
  81         } while (0)
  82
  83 #define assert_with_errno(condition)                    \
  84         assert_with_errno_((condition), #condition)
  85
  86 #define assert_no_err(condition) \
  87         assert_with_errno_(!(condition), #condition)
  88
  89 #define assert_equal(lhs, rhs, fmt)                                                                             \
  90         do {                                                                                                                            \
  91                 typeof (lhs) lhs_ = (lhs);                                                                              \
  92                 typeof (lhs) rhs_ = (rhs);                                                                              \
  93                 if (lhs_ != rhs_)                                                                                               \
  94                         assert_fail(#lhs " (" fmt ") != " #rhs " (" fmt ")",            \
  95                                                 lhs_, rhs_);                                                                    \
  96         } while (0)
  97
  98 #define assert_equal_(lhs, rhs, lhs_str, rhs_str, fmt)                                  \
  99         do {                                                                                                                            \
 100                 typeof (lhs) lhs_ = (lhs);                                                                              \
 101                 typeof (lhs) rhs_ = (rhs);                                                                              \
 102                 if (lhs_ != rhs_)                                                                                               \
 103                         assert_fail(lhs_str " (" fmt ") != " rhs_str " (" fmt ")",      \
 104                                                 lhs_, rhs_);                                                                    \
 105         } while (0)
 106
 107 #define assert_equal_int(lhs, rhs)      assert_equal_(lhs, rhs, #lhs, #rhs, "%d")
 108 #define assert_equal_ll(lhs, rhs)       assert_equal_(lhs, rhs, #lhs, #rhs, "%lld")
 109 #define assert_equal_str(lhs, rhs)                                                                              \
 110         do {                                                                                                                            \
 111                 const char *lhs_ = (lhs), *rhs_ = (rhs);                                                \
 112                 if (strcmp(lhs_, rhs_))                                                                                 \
 113                         assert_fail("\"%s\" != \"%s\"", lhs_, rhs_);                            \
 114         } while (0)
 115
 116 #define ignore_eintr(x, error_val)                                                              \
 117         ({                                                                                                                      \
 118                 typeof(x) eintr_ret_;                                                                   \
 119                 do {                                                                                                    \
 120                         eintr_ret_ = (x);                                                                       \
 121                 } while (eintr_ret_ == (error_val) && errno == EINTR);  \
 122                 eintr_ret_;                                                                                             \
 123         })
 124
 125 #endif /* test_utils_h */