realm-js/fuzzer/command_file.cpp

223 lines
5.8 KiB
C++
Raw Normal View History

2016-03-18 17:23:26 +00:00
#include "command_file.hpp"
#include "impl/realm_coordinator.hpp"
#include "shared_realm.hpp"
#include <realm/link_view.hpp>
#include <realm/table.hpp>
#include <istream>
using namespace fuzzer;
using namespace realm;
#if 0
#define log(...) fprintf(stderr, __VA_ARGS__)
#else
#define log(...)
#endif
template<typename T>
static T read_value(std::istream& input)
{
T ret;
input >> ret;
return ret;
}
template<typename... Args>
static auto make_reader(void (*fn)(RealmState&, Args...)) {
return [=](std::istream& input) {
return std::bind(fn, std::placeholders::_1, read_value<Args>(input)...);
};
}
static void run_add(RealmState& state, int64_t value)
{
log("add %lld\n", value);
size_t ndx = state.table.add_empty_row();
state.table.set_int(0, ndx, state.uid++);
state.table.set_int(1, ndx, value);
}
static void run_modify(RealmState& state, size_t index, int64_t value)
{
if (index < state.table.size()) {
log("modify %zu %lld\n", index, value);
state.table.set_int(1, index, value);
state.modified.push_back(state.table.get_int(0, index));
}
}
static void run_delete(RealmState& state, size_t index)
{
if (index < state.table.size()) {
log("delete %zu\n", index);
state.table.move_last_over(index);
}
}
static void run_commit(RealmState& state)
{
log("commit\n");
state.realm.commit_transaction();
state.coordinator.on_change();
state.realm.begin_transaction();
}
static void run_lv_insert(RealmState& state, size_t pos, size_t target)
{
if (target < state.table.size() && pos <= state.lv->size()) {
log("lv insert %zu %zu\n", pos, target);
state.lv->insert(pos, target);
}
}
static void run_lv_set(RealmState& state, size_t pos, size_t target)
{
if (target < state.table.size() && pos < state.lv->size()) {
log("lv set %zu %zu\n", pos, target);
// We can't reliably detect self-assignment for verification, so don't do it
if (state.lv->get(pos).get_index() != target)
state.lv->set(pos, target);
}
}
static void run_lv_move(RealmState& state, size_t from, size_t to)
{
if (from < state.lv->size() && to < state.lv->size()) {
log("lv move %zu %zu\n", from, to);
// FIXME: only do the move if it has an effect to avoid getting a
// notification which we weren't expecting. This is really urgh.
for (size_t i = std::min(from, to); i < std::max(from, to); ++i) {
if (state.lv->get(i).get_index() != state.lv->get(i + 1).get_index()) {
state.lv->move(from, to);
break;
}
}
}
}
static void run_lv_swap(RealmState& state, size_t ndx1, size_t ndx2)
{
if (ndx1 < state.lv->size() && ndx2 < state.lv->size()) {
log("lv swap %zu %zu\n", ndx1, ndx2);
if (state.lv->get(ndx1).get_index() != state.lv->get(ndx2).get_index()) {
state.lv->swap(ndx1, ndx2);
// FIXME: swap() needs to produce moves so that a pair of swaps can
// be collapsed away. Currently it just marks the rows as modified.
state.modified.push_back(state.lv->get(ndx1).get_int(0));
state.modified.push_back(state.lv->get(ndx2).get_int(0));
}
}
}
static void run_lv_remove(RealmState& state, size_t pos)
{
if (pos < state.lv->size()) {
log("lv remove %zu\n", pos);
state.lv->remove(pos);
}
}
static void run_lv_remove_target(RealmState& state, size_t pos)
{
if (pos < state.lv->size()) {
log("lv target remove %zu\n", pos);
state.lv->remove_target_row(pos);
}
}
static std::map<char, std::function<std::function<void (RealmState&)>(std::istream&)>> readers = {
// Row functions
{'a', make_reader(run_add)},
{'c', make_reader(run_commit)},
{'d', make_reader(run_delete)},
{'m', make_reader(run_modify)},
// LinkView functions
{'i', make_reader(run_lv_insert)},
{'s', make_reader(run_lv_set)},
{'o', make_reader(run_lv_move)},
{'w', make_reader(run_lv_swap)},
{'r', make_reader(run_lv_remove)},
{'t', make_reader(run_lv_remove_target)},
};
template<typename T>
static std::vector<T> read_int_list(std::istream& input_stream)
{
std::vector<T> ret;
std::string line;
while (std::getline(input_stream, line) && !line.empty()) {
try {
ret.push_back(std::stoll(line));
log("%lld\n", (long long)ret.back());
}
catch (std::invalid_argument) {
// not an error
}
catch (std::out_of_range) {
// not an error
}
}
log("\n");
return ret;
}
CommandFile::CommandFile(std::istream& input)
: initial_values(read_int_list<int64_t>(input))
, initial_list_indices(read_int_list<size_t>(input))
{
if (!input.good())
return;
while (input.good()) {
char op = '\0';
input >> op;
if (!input.good())
break;
auto it = readers.find(op);
if (it == readers.end())
continue;
auto fn = it->second(input);
if (!input.good())
return;
commands.push_back(std::move(fn));
}
}
void CommandFile::import(RealmState& state)
{
auto& table = state.table;
state.realm.begin_transaction();
table.clear();
size_t ndx = table.add_empty_row(initial_values.size());
for (auto value : initial_values) {
table.set_int(0, ndx, state.uid++);
table.set_int(1, ndx++, value);
}
state.lv->clear();
for (auto value : initial_list_indices) {
if (value < table.size())
state.lv->add(value);
}
state.realm.commit_transaction();
}
void CommandFile::run(RealmState& state)
{
state.realm.begin_transaction();
for (auto& command : commands) {
command(state);
}
state.realm.commit_transaction();
}