src/tests/test-bpsys.cc

   1 #include <vector>
   2 #include <utility>
   3 #include <algorithm>
   4 #include <memory>
   5 #include <map>
   6
   7 #include <cstdlib>
   8 #include <cerrno>
   9
  10 #include "baseproc-sys.h"
  11
  12 namespace {
  13
  14 std::vector<bool> usedfds = {true, true, true};
  15
  16 struct read_result
  17 {
  18         read_result(int errcode_p) : errcode(errcode_p) {}
  19
  20         read_result(std::vector<char> &data_p) : errcode(0), data(data_p) {}
  21         read_result(std::vector<char> &&data_p) : errcode(0), data(std::move(data_p)) {}
  22
  23         int errcode; // errno return
  24         std::vector<char> data;  // data (if errcode == 0)
  25 };
  26
  27 class read_cond : public std::vector<read_result>
  28 {
  29     public:
  30     using vector<read_result>::vector;
  31
  32     // if blocking, return EAGAIN rather than end-of-file:
  33     bool is_blocking = false;
  34 };
  35
  36 // map of fd to read results to supply for reads of that fd
  37 std::map<int,read_cond> read_data;
  38
  39 // map of fd to the handler for writes to that fd
  40 std::map<int, std::unique_ptr<bp_sys::write_handler>> write_hndlr_map;
  41
  42 } // anon namespace
  43
  44 namespace bp_sys {
  45
  46 int last_sig_sent = -1; // last signal number sent, accessible for tests.
  47 pid_t last_forked_pid = 1;  // last forked process id (incremented each 'fork')
  48
  49 // Test helper methods:
  50
  51 void init_bpsys()
  52 {
  53     write_hndlr_map[0] = std::unique_ptr<bp_sys::write_handler> { new default_write_handler() };
  54     write_hndlr_map[1] = std::unique_ptr<bp_sys::write_handler> { new default_write_handler() };
  55     write_hndlr_map[2] = std::unique_ptr<bp_sys::write_handler> { new default_write_handler() };
  56 }
  57
  58 // Allocate a file descriptor
  59 int allocfd()
  60 {
  61     return allocfd(new default_write_handler());
  62 }
  63
  64 int allocfd(write_handler *whndlr)
  65 {
  66     auto f = std::find(usedfds.begin(), usedfds.end(), false);
  67     if (f == usedfds.end()) {
  68         int r = usedfds.size();
  69         usedfds.push_back(true);
  70         write_hndlr_map[r] = std::unique_ptr<bp_sys::write_handler>(whndlr);
  71         return r;
  72     }
  73
  74     *f = true;
  75     auto r = f - usedfds.begin();
  76     write_hndlr_map[r] = std::unique_ptr<bp_sys::write_handler>(whndlr);
  77     return r;
  78 }
  79
  80 // Supply data to be returned by read()
  81 void supply_read_data(int fd, std::vector<char> &data)
  82 {
  83         read_data[fd].emplace_back(data);
  84 }
  85
  86 void supply_read_data(int fd, std::vector<char> &&data)
  87 {
  88         read_data[fd].emplace_back(std::move(data));
  89 }
  90
  91 void set_blocking(int fd)
  92 {
  93     read_data[fd].is_blocking = true;
  94 }
  95
  96 // retrieve data written via write()
  97 void extract_written_data(int fd, std::vector<char> &data)
  98 {
  99     auto &whandler = write_hndlr_map[fd];
 100     if (whandler == nullptr) abort();
 101     default_write_handler *dwhndlr = static_cast<default_write_handler *>(whandler.get());
 102         data = std::move(dwhndlr->data);
 103 }
 104
 105
 106 // Mock implementations of system calls:
 107
 108 int pipe2(int fds[2], int flags)
 109 {
 110     fds[0] = allocfd();
 111     fds[1] = allocfd();
 112     return 0;
 113 }
 114
 115 int close(int fd)
 116 {
 117     if (size_t(fd) >= usedfds.size()) abort();
 118     if (! usedfds[fd]) abort();
 119
 120     usedfds[fd] = false;
 121     write_hndlr_map.erase(fd);
 122     return 0;
 123 }
 124
 125 int kill(pid_t pid, int sig)
 126 {
 127     last_sig_sent = sig;
 128     return 0;
 129 }
 130
 131 ssize_t read(int fd, void *buf, size_t count)
 132 {
 133         read_cond & rrs = read_data[fd];
 134         if (rrs.empty()) {
 135             if (rrs.is_blocking) {
 136                 errno = EAGAIN;
 137                 return -1;
 138             }
 139                 return 0;
 140         }
 141
 142         read_result &rr = rrs.front();
 143         if (rr.errcode != 0) {
 144                 errno = rr.errcode;
 145                 // Remove the result record:
 146                 auto i = rrs.begin();
 147                 i++;
 148                 rrs.erase(rrs.begin(), i);
 149                 return -1;
 150         }
 151
 152         auto dsize = rr.data.size();
 153         if (dsize <= count) {
 154                 // Consume entire result:
 155                 std::copy_n(rr.data.begin(), dsize, (char *)buf);
 156                 // Remove the result record:
 157                 rrs.erase(rrs.begin());
 158                 return dsize;
 159         }
 160
 161         // Consume partial result:
 162         std::copy_n(rr.data.begin(), count, (char *)buf);
 163         rr.data.erase(rr.data.begin(), rr.data.begin() + count);
 164         return count;
 165 }
 166
 167 ssize_t write(int fd, const void *buf, size_t count)
 168 {
 169     return write_hndlr_map[fd]->write(fd, buf, count);
 170 }
 171
 172 ssize_t writev(int fd, const struct iovec *iov, int iovcnt)
 173 {
 174     ssize_t r = 0;
 175     for (int i = 0; i < iovcnt; i++) {
 176         ssize_t wr = write(fd, iov[i].iov_base, iov[i].iov_len);
 177         if (wr < 0) {
 178             if (r > 0) {
 179                 return r;
 180             }
 181             return wr;
 182         }
 183         r += wr;
 184         if (size_t(wr) < iov[i].iov_len) {
 185             return r;
 186         }
 187     }
 188     return r;
 189 }
 190
 191 }