673 lines
22 KiB
C++
673 lines
22 KiB
C++
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// This file contains the code to compare the contents of tables.
|
|
// The top level functions in this file are:
|
|
//
|
|
// World::diff_numbered_tables
|
|
// World::diff_tangible_databases
|
|
// World::patch_numbered_tables
|
|
// World::patch_tangible_databases
|
|
//
|
|
// This file also contains all the support code needed to implement
|
|
// this stuff, plus the unit tests (unittests_difftab).
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
#include "luastack.hpp"
|
|
#include "streambuffer.hpp"
|
|
#include "table.hpp"
|
|
#include "world.hpp"
|
|
|
|
// Given a table and an tnmap, return the table number of the table.
|
|
// Returns zero if the table doesn't have a table number.
|
|
//
|
|
static int get_table_number(LuaCoreStack &MLS, LuaSlot mval, LuaSlot mtnmap) {
|
|
lua_State *L = MLS.state();
|
|
lua_pushvalue(L, mval.index());
|
|
lua_rawget(L, mtnmap.index());
|
|
int result = 0;
|
|
if (lua_type(L, -1) == LUA_TNUMBER) {
|
|
result = lua_tointeger(L, -1);
|
|
}
|
|
lua_pop(L, 1);
|
|
return result;
|
|
}
|
|
|
|
|
|
static bool equivalent_values(LuaCoreStack &MLS, LuaSlot mval, LuaSlot mtnmap,
|
|
LuaCoreStack &SLS, LuaSlot sval, LuaSlot stnmap) {
|
|
switch (MLS.xtype(mval)) {
|
|
case LUA_TBOOLEAN: {
|
|
if (SLS.type(sval) != LUA_TBOOLEAN) return false;
|
|
return MLS.tryboolean(mval) == SLS.tryboolean(sval);
|
|
}
|
|
case LUA_TNUMBER: {
|
|
if (SLS.type(sval) != LUA_TNUMBER) return false;
|
|
return MLS.trynumber(mval) == SLS.trynumber(sval);
|
|
}
|
|
case LUA_TSTRING: {
|
|
if (SLS.type(sval) != LUA_TSTRING) return false;
|
|
return MLS.trystring(mval) == SLS.trystring(sval);
|
|
}
|
|
case LUA_TLIGHTUSERDATA: {
|
|
if (SLS.type(sval) != LUA_TLIGHTUSERDATA) return false;
|
|
return MLS.trytoken(mval) == SLS.trytoken(sval);
|
|
}
|
|
case LUA_TFUNCTION: {
|
|
// Cannot really compare. Just return true if the types match.
|
|
return SLS.type(sval) == MLS.type(mval);
|
|
}
|
|
case LUA_TT_GENERAL: {
|
|
int midx = get_table_number(MLS, mval, mtnmap);
|
|
if (midx == 0) {
|
|
return SLS.isnil(sval);
|
|
}
|
|
int sidx = get_table_number(SLS, sval, stnmap);
|
|
return midx == sidx;
|
|
}
|
|
case LUA_TT_CLASS: {
|
|
if (SLS.xtype(sval) != LUA_TT_CLASS) return false;
|
|
// What if it's an ill-formed class?
|
|
return MLS.classname(mval) == SLS.classname(sval);
|
|
}
|
|
case LUA_TT_TANGIBLE: {
|
|
if (SLS.xtype(sval) != LUA_TT_TANGIBLE) return false;
|
|
// What if it's an ill-formed tangible?
|
|
return MLS.tanid(mval) == SLS.tanid(sval);
|
|
}
|
|
case LUA_TT_GLOBALENV: {
|
|
return (SLS.xtype(sval) == LUA_TT_GLOBALENV);
|
|
}
|
|
default:
|
|
// We're forcing anything else to go to NIL,
|
|
// and once it's NIL, we consider it 'equal'.
|
|
return SLS.type(sval) == LUA_TNIL;
|
|
}
|
|
}
|
|
|
|
static void transmit_value(LuaCoreStack &MLS, LuaSlot mval, LuaSlot mtnmap, StreamBuffer *sb) {
|
|
switch (MLS.xtype(mval)) {
|
|
case LUA_TBOOLEAN: {
|
|
sb->write_uint8(LUA_TBOOLEAN);
|
|
sb->write_bool(*MLS.tryboolean(mval));
|
|
return;
|
|
}
|
|
case LUA_TNUMBER: {
|
|
sb->write_uint8(LUA_TNUMBER);
|
|
sb->write_double(*MLS.trynumber(mval));
|
|
return;
|
|
}
|
|
case LUA_TSTRING: {
|
|
sb->write_uint8(LUA_TSTRING);
|
|
sb->write_string(*MLS.trystring(mval));
|
|
return;
|
|
}
|
|
case LUA_TLIGHTUSERDATA: {
|
|
sb->write_uint8(LUA_TLIGHTUSERDATA);
|
|
sb->write_uint64((*MLS.trytoken(mval)).value);
|
|
return;
|
|
}
|
|
case LUA_TT_GENERAL: {
|
|
int midx = get_table_number(MLS, mval, mtnmap);
|
|
if (midx == 0) {
|
|
sb->write_uint8(LUA_TNIL);
|
|
} else {
|
|
sb->write_uint8(LUA_TT_GENERAL);
|
|
sb->write_uint32(midx);
|
|
}
|
|
return;
|
|
}
|
|
case LUA_TT_CLASS: {
|
|
sb->write_uint8(LUA_TT_CLASS);
|
|
sb->write_string(MLS.classname(mval));
|
|
return;
|
|
}
|
|
case LUA_TT_TANGIBLE: {
|
|
sb->write_uint8(LUA_TT_TANGIBLE);
|
|
sb->write_int64(MLS.tanid(mval));
|
|
return;
|
|
}
|
|
case LUA_TT_GLOBALENV: {
|
|
sb->write_uint8(LUA_TT_GLOBALENV);
|
|
return;
|
|
}
|
|
default:
|
|
sb->write_uint8(LUA_TNIL);
|
|
return;
|
|
}
|
|
}
|
|
|
|
static bool diff_tables(LuaCoreStack &SLS0, LuaSlot stnmap, LuaSlot stab,
|
|
LuaCoreStack &MLS0, LuaSlot mtnmap, LuaSlot mtab,
|
|
bool cmeta, StreamBuffer *sb) {
|
|
LuaVar skey, mkey, sval, mval, mnil;
|
|
LuaExtStack SLS(SLS0.state(), skey, sval);
|
|
LuaExtStack MLS(MLS0.state(), mkey, mval, mnil);
|
|
assert(MLS.istable(mtab));
|
|
assert(SLS.istable(stab));
|
|
MLS.set(mnil, LuaNil);
|
|
int nupdates = 0;
|
|
|
|
sb->write_int32(0);
|
|
int wc = sb->total_writes();
|
|
|
|
MLS.set(mkey, LuaNil);
|
|
while (MLS.next(mtab, mkey, mval)) {
|
|
if (!MLS.issortablekey(mkey)) continue;
|
|
MLS.movesortablekey(mkey, SLS, skey);
|
|
SLS.rawget(sval, stab, skey);
|
|
if (!equivalent_values(MLS, mval, mtnmap, SLS, sval, stnmap)) {
|
|
transmit_value(MLS, mkey, mtnmap, sb);
|
|
transmit_value(MLS, mval, mtnmap, sb);
|
|
nupdates += 1;
|
|
}
|
|
}
|
|
|
|
SLS.set(skey, LuaNil);
|
|
while (SLS.next(stab, skey, sval)) {
|
|
if (!SLS.issortablekey(skey)) continue;
|
|
SLS.movesortablekey(skey, MLS, mkey);
|
|
MLS.rawget(mval, mtab, mkey);
|
|
if (MLS.isnil(mval)) {
|
|
transmit_value(MLS, mkey, mtnmap, sb);
|
|
transmit_value(MLS, mval, mtnmap, sb);
|
|
nupdates += 1;
|
|
}
|
|
}
|
|
|
|
if (cmeta) {
|
|
SLS.getmetatable(sval, stab);
|
|
MLS.getmetatable(mval, mtab);
|
|
if (!equivalent_values(MLS, mval, mtnmap, SLS, sval, stnmap)) {
|
|
transmit_value(MLS, mnil, mtnmap, sb);
|
|
transmit_value(MLS, mval, mtnmap, sb);
|
|
nupdates += 1;
|
|
}
|
|
}
|
|
|
|
sb->overwrite_int32(wc, nupdates);
|
|
return (nupdates > 0);
|
|
}
|
|
|
|
static void set_transmitted_value(LuaCoreStack &LS, LuaSlot tangibles, LuaSlot ntmap, LuaSlot target, StreamBuffer *sb, const char *dbinfo, DebugCollector *dbc) {
|
|
int kind = sb->read_uint8();
|
|
switch (kind) {
|
|
case LUA_TBOOLEAN: {
|
|
bool value = sb->read_bool();
|
|
DebugLine(dbc) << dbinfo << (value ? "true" : "false");
|
|
LS.set(target, value);
|
|
return;
|
|
}
|
|
case LUA_TNUMBER: {
|
|
double value = sb->read_double();
|
|
DebugLine(dbc) << dbinfo << value;
|
|
LS.set(target, value);
|
|
return;
|
|
}
|
|
case LUA_TSTRING: {
|
|
eng::string value = sb->read_string();
|
|
DebugLine(dbc) << dbinfo << "'" << value << "'";
|
|
LS.set(target, value);
|
|
return;
|
|
}
|
|
case LUA_TLIGHTUSERDATA: {
|
|
LuaToken value(sb->read_uint64());
|
|
DebugLine(dbc) << dbinfo << "[" << value.str() << "]";
|
|
LS.set(target, value);
|
|
return;
|
|
}
|
|
case LUA_TT_GENERAL: {
|
|
int index = sb->read_int32();
|
|
DebugLine(dbc) << dbinfo << "table " << index;
|
|
LS.rawget(target, ntmap, index);
|
|
return;
|
|
}
|
|
case LUA_TT_CLASS: {
|
|
eng::string value = sb->read_string();
|
|
DebugLine(dbc) << dbinfo << "class " << value;
|
|
LS.makeclass(target, value);
|
|
return;
|
|
}
|
|
case LUA_TT_TANGIBLE: {
|
|
int64_t id = sb->read_int64();
|
|
DebugLine(dbc) << dbinfo << "tan " << id;
|
|
LS.maketan(target, id);
|
|
return;
|
|
}
|
|
case LUA_TT_GLOBALENV: {
|
|
DebugLine(dbc) << dbinfo << "global env";
|
|
LS.getglobaltable(target);
|
|
return;
|
|
}
|
|
case LUA_TNIL: {
|
|
DebugLine(dbc) << dbinfo << "nil";
|
|
LS.set(target, LuaNil);
|
|
return;
|
|
}
|
|
default:
|
|
assert(false); // Should not get here.
|
|
}
|
|
}
|
|
|
|
static void patch_table(LuaCoreStack &LS0, LuaSlot tangibles, LuaSlot ntmap, LuaSlot tab, StreamBuffer *sb, DebugCollector *dbc) {
|
|
LuaVar key, val;
|
|
LuaExtStack LS(LS0.state(), key, val);
|
|
int ndiffs = sb->read_int32();
|
|
for (int i = 0; i < ndiffs; i++) {
|
|
set_transmitted_value(LS, tangibles, ntmap, key, sb, "key=", dbc);
|
|
set_transmitted_value(LS, tangibles, ntmap, val, sb, "val=", dbc);
|
|
if (LS.isnil(key)) {
|
|
LS.setmetatable(tab, val);
|
|
} else {
|
|
LS.rawset(tab, key, val);
|
|
}
|
|
}
|
|
}
|
|
|
|
void World::patch_numbered_tables(StreamBuffer *sb, DebugCollector *dbc) {
|
|
lua_State *L = state();
|
|
LuaVar tangibles, ntmap, tab;
|
|
LuaExtStack LS(L, tangibles, ntmap, tab);
|
|
LS.rawget(tangibles, LuaRegistry, "tangibles");
|
|
LS.rawget(ntmap, LuaRegistry, "ntmap");
|
|
assert(LS.istable(tangibles));
|
|
assert(LS.istable(ntmap));
|
|
|
|
int nmodified = sb->read_int32();
|
|
for (int i = 0; i < nmodified; i++) {
|
|
int index = sb->read_int32();
|
|
LS.rawget(tab, ntmap, index);
|
|
assert(LS.istable(tab));
|
|
DebugHeader(dbc) << "Lua Table " << index << ":";
|
|
patch_table(LS, tangibles, ntmap, tab, sb, dbc);
|
|
}
|
|
}
|
|
|
|
void World::diff_numbered_tables(lua_State *master, StreamBuffer *sb) {
|
|
lua_State *synch = state();
|
|
LuaVar sntmap, mntmap, stnmap, mtnmap, stab, mtab;
|
|
LuaExtStack SLS(synch, sntmap, stnmap, stab);
|
|
LuaExtStack MLS(master, mntmap, mtnmap, mtab);
|
|
SLS.rawget(sntmap, LuaRegistry, "ntmap");
|
|
MLS.rawget(mntmap, LuaRegistry, "ntmap");
|
|
SLS.rawget(stnmap, LuaRegistry, "tnmap");
|
|
MLS.rawget(mtnmap, LuaRegistry, "tnmap");
|
|
int m_ntables = MLS.rawlen(mntmap);
|
|
int s_ntables = SLS.rawlen(sntmap);
|
|
assert(m_ntables == s_ntables);
|
|
|
|
sb->write_int32(0);
|
|
int write_count_after = sb->total_writes();
|
|
int nmodified = 0;
|
|
int s_top = lua_gettop(synch);
|
|
int m_top = lua_gettop(master);
|
|
for (int id = 1; id <= m_ntables; id++) {
|
|
MLS.rawget(mtab, mntmap, id);
|
|
if (MLS.istable(mtab)) {
|
|
SLS.rawget(stab, sntmap, id);
|
|
assert(SLS.istable(stab));
|
|
int tw = sb->total_writes();
|
|
sb->write_int32(id);
|
|
nmodified += 1;
|
|
if (!diff_tables(SLS, stnmap, stab, MLS, mtnmap, mtab, true, sb)) {
|
|
sb->unwrite_to(tw);
|
|
nmodified -= 1;
|
|
}
|
|
}
|
|
assert(lua_gettop(synch) == s_top);
|
|
assert(lua_gettop(master) == m_top);
|
|
}
|
|
sb->overwrite_int32(write_count_after, nmodified);
|
|
}
|
|
|
|
void World::patch_tangible_databases(StreamBuffer *sb, DebugCollector *dbc) {
|
|
lua_State *L = state();
|
|
LuaVar tangibles, ntmap, tab;
|
|
LuaExtStack LS(L, tangibles, ntmap, tab);
|
|
LS.rawget(tangibles, LuaRegistry, "tangibles");
|
|
LS.rawget(ntmap, LuaRegistry, "ntmap");
|
|
assert(LS.istable(tangibles));
|
|
assert(LS.istable(ntmap));
|
|
|
|
int nmodified = sb->read_int32();
|
|
for (int i = 0; i < nmodified; i++) {
|
|
int64_t id = sb->read_int64();
|
|
LS.rawget(tab, tangibles, id);
|
|
assert(LS.istable(tab));
|
|
DebugHeader(dbc) << "Tangible DB " << id << ":";
|
|
patch_table(LS, tangibles, ntmap, tab, sb, dbc);
|
|
}
|
|
}
|
|
|
|
void World::diff_tangible_databases(const IdVector &basis, lua_State *master, StreamBuffer *sb) {
|
|
lua_State *synch = state();
|
|
LuaVar stnmap, mtnmap, stangibles, mtangibles, stab, mtab;
|
|
LuaExtStack SLS(synch, stnmap, stangibles, stab);
|
|
LuaExtStack MLS(master, mtnmap, mtangibles, mtab);
|
|
SLS.rawget(stnmap, LuaRegistry, "tnmap");
|
|
MLS.rawget(mtnmap, LuaRegistry, "tnmap");
|
|
SLS.rawget(stangibles, LuaRegistry, "tangibles");
|
|
MLS.rawget(mtangibles, LuaRegistry, "tangibles");
|
|
|
|
sb->write_int32(0);
|
|
int write_count_after = sb->total_writes();
|
|
int nmodified = 0;
|
|
int s_top = lua_gettop(synch);
|
|
int m_top = lua_gettop(master);
|
|
for (int64_t id : basis) {
|
|
MLS.rawget(mtab, mtangibles, id);
|
|
SLS.rawget(stab, stangibles, id);
|
|
assert(MLS.istable(mtab));
|
|
assert(SLS.istable(stab));
|
|
int tw = sb->total_writes();
|
|
sb->write_int64(id);
|
|
nmodified += 1;
|
|
if (!diff_tables(SLS, stnmap, stab, MLS, mtnmap, mtab, false, sb)) {
|
|
sb->unwrite_to(tw);
|
|
nmodified -= 1;
|
|
}
|
|
assert(lua_gettop(synch) == s_top);
|
|
assert(lua_gettop(master) == m_top);
|
|
}
|
|
sb->overwrite_int32(write_count_after, nmodified);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Unit Testing Framework for Table Diff
|
|
//
|
|
// The function test_diffcompare creates a standalone lua environment,
|
|
// evaluates two lua expressions to build a master table and a synch
|
|
// table, runs diff_tables, and returns the result as a debug string.
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
#include "source.hpp"
|
|
#include "traceback.hpp"
|
|
#include "pprint.hpp"
|
|
#include "wrap-sstream.hpp"
|
|
|
|
class DiffTester {
|
|
lua_State *master_L_ = nullptr;
|
|
lua_State *synch_L_ = nullptr;
|
|
lua_State *caller_;
|
|
SourceDB master_sdb_;
|
|
SourceDB synch_sdb_;
|
|
|
|
static void transmit_value_debug_string(StreamBuffer *sb, eng::ostringstream &oss) {
|
|
int kind = sb->read_uint8();
|
|
switch (kind) {
|
|
case LUA_TBOOLEAN: {
|
|
bool b = sb->read_bool();
|
|
oss << (b ? "true":"false");
|
|
return;
|
|
}
|
|
case LUA_TNUMBER: {
|
|
oss << sb->read_double();
|
|
return;
|
|
}
|
|
case LUA_TSTRING: {
|
|
oss << sb->read_string();
|
|
return;
|
|
}
|
|
case LUA_TLIGHTUSERDATA: {
|
|
LuaToken token(sb->read_uint64());
|
|
oss << "[" << token.str() << "]";
|
|
return;
|
|
}
|
|
case LUA_TT_GENERAL: {
|
|
oss << "tab" << sb->read_int32();
|
|
return;
|
|
}
|
|
case LUA_TT_CLASS: {
|
|
oss << "class " << sb->read_string();
|
|
return;
|
|
}
|
|
case LUA_TT_TANGIBLE: {
|
|
oss << "tan " << sb->read_int64();
|
|
return;
|
|
}
|
|
case LUA_TT_GLOBALENV: {
|
|
oss << "globals";
|
|
return;
|
|
}
|
|
case LUA_TNIL: {
|
|
oss << "nil";
|
|
return;
|
|
}
|
|
default:
|
|
assert(false); // Should not get here.
|
|
}
|
|
}
|
|
|
|
static eng::string diff_tables_debug_string(StreamBuffer *sb) {
|
|
eng::vector<eng::string> sorted;
|
|
eng::ostringstream oss;
|
|
int ndiffs = sb->read_int32();
|
|
for (int i = 0; i < ndiffs; i++) {
|
|
transmit_value_debug_string(sb, oss);
|
|
oss << "=";
|
|
transmit_value_debug_string(sb, oss);
|
|
sorted.push_back(oss.str());
|
|
oss.str("");
|
|
}
|
|
std::sort(sorted.begin(), sorted.end());
|
|
for (const eng::string &s : sorted) {
|
|
oss << s << ";";
|
|
}
|
|
return oss.str();
|
|
}
|
|
|
|
public:
|
|
DiffTester(lua_State *caller) : caller_(caller) {
|
|
master_L_ = LuaCoreStack::newstate(eng::l_alloc);
|
|
synch_L_ = LuaCoreStack::newstate(eng::l_alloc);
|
|
master_sdb_.init(master_L_);
|
|
synch_sdb_.init(synch_L_);
|
|
}
|
|
|
|
~DiffTester() {
|
|
if (master_L_) lua_close(master_L_);
|
|
if (synch_L_) lua_close(synch_L_);
|
|
}
|
|
|
|
// Create stock test tables and their maps in a single lua environment.
|
|
// Sets up globals tab1-tab9 and populates the tnmap and ntmap.
|
|
void create_stock_tables(LuaCoreStack &LS, LuaSlot tnmap, LuaSlot ntmap) {
|
|
lua_State *L = LS.state();
|
|
LuaVar globtab;
|
|
LuaExtStack LS2(L, globtab);
|
|
LS.set(tnmap, LuaNewTable);
|
|
LS.set(ntmap, LuaNewTable);
|
|
LS.getglobaltable(globtab);
|
|
for (int i = 1; i <= 9; i++) {
|
|
LuaVar tabi;
|
|
LuaExtStack LS3(L, tabi);
|
|
LS.set(tabi, LuaNewTable);
|
|
LS.rawset(tabi, 1, util::ss("tab", i));
|
|
LS.rawset(globtab, util::ss("tab", i), tabi);
|
|
LS.rawset(tnmap, tabi, i);
|
|
LS.rawset(ntmap, i, tabi);
|
|
}
|
|
}
|
|
|
|
// Pretty-print a lua value to a string.
|
|
eng::string pprint(LuaCoreStack &LS, LuaSlot val) {
|
|
std::ostringstream oss;
|
|
PrettyPrint::Indented().print(LS, val, &oss);
|
|
return eng::string(oss.str());
|
|
}
|
|
|
|
// Evaluate a lua expression and store the result in the given slot.
|
|
void eval(LuaCoreStack &LS, LuaSlot dest, const char *expr, const char *name) {
|
|
lua_State *L = LS.state();
|
|
LuaVar closure;
|
|
LuaExtStack LS2(L, closure);
|
|
eng::string err = LS2.load(closure, util::ss("return ", expr), name);
|
|
LuaAssert(caller_, err.empty());
|
|
lua_pushvalue(L, closure.index());
|
|
err = traceback_pcall(L, 0, 1);
|
|
LuaAssert(caller_, err.empty());
|
|
lua_replace(L, dest.index());
|
|
}
|
|
|
|
eng::string diffcompare(const char *master_expr, const char *synch_expr) {
|
|
assert(lua_gettop(master_L_) == 0);
|
|
assert(lua_gettop(synch_L_) == 0);
|
|
|
|
LuaVar mtnmap, mntmap, mtab;
|
|
LuaExtStack MLS(master_L_, mtnmap, mntmap, mtab);
|
|
LuaVar stnmap, sntmap, stab;
|
|
LuaExtStack SLS(synch_L_, stnmap, sntmap, stab);
|
|
|
|
create_stock_tables(MLS, mtnmap, mntmap);
|
|
create_stock_tables(SLS, stnmap, sntmap);
|
|
eval(MLS, mtab, master_expr, "master");
|
|
eval(SLS, stab, synch_expr, "synch");
|
|
|
|
// Run diff_tables.
|
|
StreamBuffer sb;
|
|
diff_tables(SLS, stnmap, stab, MLS, mtnmap, mtab, true, &sb);
|
|
|
|
return diff_tables_debug_string(&sb);
|
|
}
|
|
|
|
bool diffapply(const char *master_expr, const char *synch_expr, bool verbose = false) {
|
|
assert(lua_gettop(master_L_) == 0);
|
|
assert(lua_gettop(synch_L_) == 0);
|
|
|
|
LuaVar mtnmap, mntmap, mtab;
|
|
LuaExtStack MLS(master_L_, mtnmap, mntmap, mtab);
|
|
LuaVar stnmap, sntmap, stab, tangibles;
|
|
LuaExtStack SLS(synch_L_, stnmap, sntmap, stab, tangibles);
|
|
|
|
create_stock_tables(MLS, mtnmap, mntmap);
|
|
create_stock_tables(SLS, stnmap, sntmap);
|
|
eval(MLS, mtab, master_expr, "master");
|
|
eval(SLS, stab, synch_expr, "synch");
|
|
|
|
// Get the tangibles map from the synch environment.
|
|
SLS.rawget(tangibles, LuaRegistry, "tangibles");
|
|
|
|
// Diff and patch.
|
|
StreamBuffer sb;
|
|
diff_tables(SLS, stnmap, stab, MLS, mtnmap, mtab, true, &sb);
|
|
if (verbose) {
|
|
StreamBuffer sb_copy(sb.view());
|
|
eng::string diff_str = diff_tables_debug_string(&sb_copy);
|
|
printf("diffapply: master_expr = %s\n", master_expr);
|
|
printf("diffapply: synch_expr = %s\n", synch_expr);
|
|
printf("diffapply: diff = %s\n", diff_str.c_str());
|
|
}
|
|
patch_table(SLS, tangibles, sntmap, stab, &sb, nullptr);
|
|
|
|
// Check equality by pretty-printing both tables and comparing.
|
|
eng::string master_str = pprint(MLS, mtab);
|
|
eng::string synch_str = pprint(SLS, stab);
|
|
if (verbose) {
|
|
printf("diffapply: master pprint (%d chars) = %s\n", (int)master_str.size(), master_str.c_str());
|
|
printf("diffapply: synch pprint (%d chars) = %s\n", (int)synch_str.size(), synch_str.c_str());
|
|
}
|
|
return master_str == synch_str;
|
|
}
|
|
};
|
|
|
|
LuaDefine(unittests_difftab, "", "unit tests for table diff") {
|
|
DiffTester dt(L);
|
|
|
|
// No differences in these simple-valued tables.
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=true}", "{a=true}"), "");
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=5}", "{a=5}"), "");
|
|
LuaAssertStrEq(L, dt.diffcompare("{a='foo'}", "{a='foo'}"), "");
|
|
|
|
// Test transmission of missing simple values.
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=true}", "{}"), "a=true;");
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=5}", "{}"), "a=5;");
|
|
LuaAssertStrEq(L, dt.diffcompare("{a='foo'}", "{}"), "a=foo;");
|
|
|
|
// Test the replacement of simple values.
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=true}", "{a=false}"), "a=true;");
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=5}", "{a=4}"), "a=5;");
|
|
LuaAssertStrEq(L, dt.diffcompare("{a='foo'}", "{a='bar'}"), "a=foo;");
|
|
|
|
// Test the clearing of values.
|
|
LuaAssertStrEq(L, dt.diffcompare("{}", "{a=true}"), "a=nil;");
|
|
LuaAssertStrEq(L, dt.diffcompare("{}", "{a=5}"), "a=nil;");
|
|
LuaAssertStrEq(L, dt.diffcompare("{}", "{a='foo'}"), "a=nil;");
|
|
|
|
// Try boolean keys.
|
|
LuaAssertStrEq(L, dt.diffcompare("{[true]=3}", "{}"), "true=3;");
|
|
LuaAssertStrEq(L, dt.diffcompare("{}", "{[true]=3}"), "true=nil;");
|
|
|
|
// Try number keys.
|
|
LuaAssertStrEq(L, dt.diffcompare("{[7]=3}", "{}"), "7=3;");
|
|
LuaAssertStrEq(L, dt.diffcompare("{}", "{[7]=3}"), "7=nil;");
|
|
|
|
// Try a table with multiple keys.
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=4, b=5, c=6}", "{b=5, c=7, d=8}"), "a=4;c=6;d=nil;");
|
|
|
|
// Nonsortable keys should be ignored (no diffs).
|
|
LuaAssertStrEq(L, dt.diffcompare("{[{}]=3}", "{}"), "");
|
|
|
|
// Numbered tables: matching pairs produce no diff.
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=tab1}", "{a=tab1}"), "");
|
|
|
|
// Numbered tables: missing in synch.
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=tab1}", "{}"), "a=tab1;");
|
|
|
|
// Numbered tables: wrong table number.
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=tab1}", "{a=tab2}"), "a=tab1;");
|
|
|
|
// Numbered tables: replaced by simple value.
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=3}", "{a=tab1}"), "a=3;");
|
|
|
|
// Numbered tables: cleared.
|
|
LuaAssertStrEq(L, dt.diffcompare("{}", "{a=tab1}"), "a=nil;");
|
|
|
|
// Unnumbered tables are forced to nil.
|
|
LuaAssertStrEq(L, dt.diffcompare("{a={}}", "{}"), "");
|
|
LuaAssertStrEq(L, dt.diffcompare("{a={}}", "{a=3}"), "a=nil;");
|
|
|
|
// Class values.
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=deque}", "{}"), "a=class deque;");
|
|
|
|
// Global environment.
|
|
LuaAssertStrEq(L, dt.diffcompare("{a=_G}", "{}"), "a=globals;");
|
|
|
|
// Metatable: set, match, clear.
|
|
LuaAssertStrEq(L, dt.diffcompare("setmetatable({}, tab1)", "{}"), "nil=tab1;");
|
|
LuaAssertStrEq(L, dt.diffcompare("setmetatable({}, tab1)", "setmetatable({}, tab1)"), "");
|
|
LuaAssertStrEq(L, dt.diffcompare("{}", "setmetatable({}, tab1)"), "nil=nil;");
|
|
|
|
// Diff-apply: verify simple values.
|
|
LuaAssert(L, dt.diffapply("{a=1}", "{}"));
|
|
LuaAssert(L, dt.diffapply("{[true]='foo'}", "{}"));
|
|
LuaAssert(L, dt.diffapply("{[3]=false}", "{}"));
|
|
|
|
// Diff-apply: multiple simple values.
|
|
LuaAssert(L, dt.diffapply("{a=1, b=2, c=3}", "{}"));
|
|
|
|
// Diff-apply: remove or replace wrong values.
|
|
LuaAssert(L, dt.diffapply("{a=1, b=2}", "{b=3, c=4}"));
|
|
|
|
// Diff-apply: table containing a numbered table.
|
|
LuaAssert(L, dt.diffapply("{a=tab1, b=tab2}", "{}"));
|
|
|
|
// Diff-apply: table containing a class.
|
|
LuaAssert(L, dt.diffapply("{a=deque, b=table}", "{}"));
|
|
|
|
// Diff-apply: table containing the global environment.
|
|
LuaAssert(L, dt.diffapply("{a=_G}", "{}"));
|
|
|
|
// Diff-apply: unnumbered tables are forced to nil.
|
|
LuaAssert(L, !dt.diffapply("{a={}}", "{a=3}"));
|
|
|
|
// Diff-apply: set metatable.
|
|
LuaAssert(L, dt.diffapply("setmetatable({}, tab1)", "{}"));
|
|
|
|
// Diff-apply: clear metatable.
|
|
LuaAssert(L, dt.diffapply("{}", "setmetatable({}, tab1)"));
|
|
|
|
return 0;
|
|
}
|