mudb
Version:
Real-time database for multiplayer games
319 lines • 13.6 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const test = require("tape");
const schema_1 = require("../../schema");
const index_1 = require("../index");
function testInverse(t, store, rda, action, msg) {
const origin = store.state(rda, rda.stateSchema.alloc());
const inverse = store.inverse(rda, action);
store.apply(rda, action);
store.apply(rda, inverse);
t.deepEqual(store.state(rda, rda.stateSchema.alloc()), origin, msg);
}
test('inverse - register', (t) => {
const Uint32Reg = new index_1.MuRDARegister(new schema_1.MuUint32());
const Uint32RegStore = Uint32Reg.createStore(-54321);
testInverse(t, Uint32RegStore, Uint32Reg, Uint32Reg.action(54321), 'set to 54321');
const ModReg = new index_1.MuRDARegister(new schema_1.MuStruct({
name: new schema_1.MuASCII(),
version: new schema_1.MuUint32(),
}));
const ModRegStore = ModReg.createStore({ name: 'default', version: 1 });
testInverse(t, ModRegStore, ModReg, ModReg.action({ name: `Don't Starve`, version: 101 }), `set to Don't Starve mod`);
t.end();
});
test('inverse - struct', (t) => {
const S = new index_1.MuRDAStruct({
r: new index_1.MuRDARegister(new schema_1.MuStruct({
a: new schema_1.MuASCII(),
f: new schema_1.MuFloat64(),
})),
s: new index_1.MuRDAStruct({
r: new index_1.MuRDARegister(new schema_1.MuStruct({
a: new schema_1.MuASCII(),
f: new schema_1.MuFloat64(),
})),
s: new index_1.MuRDAStruct({
a: new index_1.MuRDARegister(new schema_1.MuASCII()),
f: new index_1.MuRDARegister(new schema_1.MuFloat64()),
}),
}),
});
const store = S.createStore(S.stateSchema.alloc());
const dispatcher = S.action(store);
const actions = [];
actions.push(dispatcher.r({ a: 'never', f: Infinity }));
actions.push(dispatcher.s.r({ a: 'vanishing', f: -Infinity }));
actions.push(dispatcher.s.s.a('overlooked'));
actions.push(dispatcher.s.s.f(0.0000000000000000000001));
const inverses = [];
for (let i = 0; i < actions.length; ++i) {
inverses.push(store.inverse(S, actions[i]));
}
testInverse(t, store, S, actions[0], 'set r');
testInverse(t, store, S, actions[1], 'set s.r');
testInverse(t, store, S, actions[2], 'set s.s.a');
testInverse(t, store, S, actions[3], 'set s.s.f');
for (let i = 0; i < actions.length; ++i) {
store.apply(S, actions[i]);
}
for (let i = 0; i < inverses.length; ++i) {
store.apply(S, inverses[i]);
}
t.deepEqual(store.state(S, S.stateSchema.alloc()), S.stateSchema.alloc());
t.end();
});
test('map', (t) => {
const M = new index_1.MuRDAMap(new schema_1.MuASCII(), new index_1.MuRDAConstant(new schema_1.MuFloat64()));
const store = M.createStore({ foo: 11.11, bar: 22.22, baz: 33.33 });
const dispatchers = M.action(store);
const actions = [];
actions.push(dispatchers.clear());
actions.push(dispatchers.reset({ foo: 22.22, bar: 22.22 }));
actions.push(dispatchers.set('foo', 33.33));
actions.push(dispatchers.remove('foo'));
actions.push(dispatchers.move('bar', 'baz'));
actions.push(dispatchers.move('baz', 'qux'));
actions.push(dispatchers.set('qux', 44.44));
actions.push(dispatchers.set('quux', 55.55));
for (let i = 0; i < actions.length; ++i) {
const action = actions[i];
testInverse(t, store, M, action, JSON.stringify(action));
}
const inverses = [];
for (let i = 0; i < actions.length; ++i) {
const action = actions[i];
inverses.push(store.inverse(M, action));
store.apply(M, actions[i]);
}
while (inverses.length > 0) {
store.apply(M, inverses.pop());
}
t.deepEqual(store.state(M, {}), { foo: 11.11, bar: 22.22, baz: 33.33 });
t.end();
});
test('map of structs', (t) => {
const M = new index_1.MuRDAMap(new schema_1.MuASCII(), new index_1.MuRDAStruct({
r: new index_1.MuRDARegister(new schema_1.MuFloat64()),
s: new index_1.MuRDAStruct({
r: new index_1.MuRDARegister(new schema_1.MuUTF8()),
}),
}));
const store = M.createStore({
foo: { r: 11.11, s: { r: '11.11' } },
bar: { r: 22.11, s: { r: '22.11' } },
baz: { r: 33.11, s: { r: '33.11' } },
});
const dispatchers = M.action(store);
const actions = [];
actions.push(dispatchers.update('foo').r(11.22));
actions.push(dispatchers.update('foo').s.r('11.22'));
actions.push(dispatchers.clear());
actions.push(dispatchers.reset({
foo: { r: 11.22, s: { r: '11.22' } },
bar: { r: 22.11, s: { r: '22.11' } },
}));
actions.push(dispatchers.set('foo', { r: 11.33, s: { r: '11.33' } }));
actions.push(dispatchers.remove('foo'));
actions.push(dispatchers.move('bar', 'baz'));
actions.push(dispatchers.move('baz', 'qux'));
actions.push(dispatchers.set('qux', { r: 44.11, s: { r: '44.11' } }));
actions.push(dispatchers.set('quux', { r: 55.11, s: { r: '55.11' } }));
for (let i = 0; i < actions.length; ++i) {
const action = actions[i];
testInverse(t, store, M, action, JSON.stringify(action));
}
const inverses = [];
for (let i = 0; i < actions.length; ++i) {
const action = actions[i];
inverses.push(store.inverse(M, action));
store.apply(M, action);
}
while (inverses.length > 0) {
store.apply(M, inverses.pop());
}
t.deepEqual(store.state(M, {}), {
foo: { r: 11.11, s: { r: '11.11' } },
bar: { r: 22.11, s: { r: '22.11' } },
baz: { r: 33.11, s: { r: '33.11' } },
});
t.end();
});
test('map of maps', (t) => {
const M = new index_1.MuRDAMap(new schema_1.MuASCII(), new index_1.MuRDAMap(new schema_1.MuASCII(), new index_1.MuRDAConstant(new schema_1.MuFloat64())));
const store = M.createStore({ foo: { bar: 11.11, baz: 22.22, qux: 33.33 } });
const dispatchers = M.action(store);
const actions = [];
actions.push(dispatchers.update('foo').clear());
actions.push(dispatchers.update('foo').reset({ bar: 22.11, baz: 22.22 }));
actions.push(dispatchers.update('foo').set('bar', 33.33));
actions.push(dispatchers.update('foo').remove('bar'));
actions.push(dispatchers.update('foo').move('baz', 'qux'));
actions.push(dispatchers.update('foo').move('qux', 'quux'));
actions.push(dispatchers.update('foo').set('quux', 44.44));
actions.push(dispatchers.update('foo').set('quuz', 55.55));
for (let i = 0; i < actions.length; ++i) {
const action = actions[i];
testInverse(t, store, M, action, JSON.stringify(action));
}
const inverses = [];
for (let i = 0; i < actions.length; ++i) {
const action = actions[i];
inverses.push(store.inverse(M, action));
store.apply(M, action);
}
while (inverses.length > 0) {
store.apply(M, inverses.pop());
}
t.deepEqual(store.state(M, {}), { foo: { bar: 11.11, baz: 22.22, qux: 33.33 } });
t.end();
});
test('map of structs of maps of structs', (t) => {
const M = new index_1.MuRDAMap(new schema_1.MuASCII(), new index_1.MuRDAStruct({
m: new index_1.MuRDAMap(new schema_1.MuASCII(), new index_1.MuRDAStruct({
k: new index_1.MuRDARegister(new schema_1.MuASCII()),
v: new index_1.MuRDARegister(new schema_1.MuFloat64()),
})),
}));
const store = M.createStore({
foo: { m: {
foo: { k: 'foo', v: 11.11 },
bar: { k: 'bar', v: 22.22 },
baz: { k: 'baz', v: 33.33 },
} },
});
const dispatchers = M.action(store);
const actions = [];
actions.push(dispatchers.update('foo').m.update('foo').k('f'));
actions.push(dispatchers.update('foo').m.update('foo').v(1.1));
actions.push(dispatchers.update('foo').m.clear());
actions.push(dispatchers.update('foo').m.reset({
foo: { k: 'foo', v: 22.22 },
bar: { k: 'bar', v: 22.22 },
}));
actions.push(dispatchers.update('foo').m.set('foo', { k: 'f', v: 1.1 }));
actions.push(dispatchers.update('foo').m.remove('foo'));
actions.push(dispatchers.update('foo').m.move('bar', 'baz'));
actions.push(dispatchers.update('foo').m.move('baz', 'qux'));
actions.push(dispatchers.update('foo').m.set('qux', { k: 'qux', v: 33.33 }));
actions.push(dispatchers.update('foo').m.set('quux', { k: 'quux', v: 44.44 }));
for (let i = 0; i < actions.length; ++i) {
const action = actions[i];
testInverse(t, store, M, action, JSON.stringify(action));
}
const inverses = [];
for (let i = 0; i < actions.length; ++i) {
const action = actions[i];
inverses.push(store.inverse(M, action));
store.apply(M, action);
}
while (inverses.length > 0) {
store.apply(M, inverses.pop());
}
t.deepEqual(store.state(M, {}), {
foo: { m: {
foo: { k: 'foo', v: 11.11 },
bar: { k: 'bar', v: 22.22 },
baz: { k: 'baz', v: 33.33 },
} },
});
t.end();
});
test('inverse - list', (t) => {
const L = new index_1.MuRDAList(new index_1.MuRDARegister(new schema_1.MuFloat64()));
const store = L.createStore([1.11, 2.22, 3.33, 4.44, 5.55]);
const dispatchers = L.action(store);
const actions = [];
actions.push(dispatchers.splice(1, 2));
actions.push(dispatchers.shift());
actions.push(dispatchers.pop());
actions.push(dispatchers.unshift(1.11, 2.22));
actions.push(dispatchers.push(5.55, 6.66));
actions.push(dispatchers.splice(2, 0, 3.33));
actions.push(dispatchers.reset([11.1, 22.2, 33.3]));
actions.push(dispatchers.clear());
testInverse(t, store, L, actions[0], 'remove');
testInverse(t, store, L, actions[1], 'shift');
testInverse(t, store, L, actions[2], 'pop');
testInverse(t, store, L, actions[3], 'unshift');
testInverse(t, store, L, actions[4], 'push');
testInverse(t, store, L, actions[5], 'insert');
testInverse(t, store, L, actions[6], 'reset');
testInverse(t, store, L, actions[7], 'clear');
const inverses = [];
for (let i = 0; i < actions.length; ++i) {
inverses.push(store.inverse(L, actions[i]));
}
testInverse(t, store, L, inverses[0], 'remove inverse');
testInverse(t, store, L, inverses[1], 'shift inverse');
testInverse(t, store, L, inverses[2], 'pop inverse');
testInverse(t, store, L, inverses[3], 'unshift inverse');
testInverse(t, store, L, inverses[4], 'push inverse');
testInverse(t, store, L, inverses[5], 'insert inverse');
testInverse(t, store, L, inverses[6], 'reset inverse');
testInverse(t, store, L, inverses[7], 'clear inverse');
for (let i = 0; i < actions.length; ++i) {
store.apply(L, actions[i]);
}
for (let i = 0; i < inverses.length; ++i) {
store.apply(L, inverses[i]);
}
t.deepEqual(store.state(L, []), [1.11, 2.22, 3.33, 4.44, 5.55]);
t.end();
});
test('inverse - list of lists', (t) => {
const L = new index_1.MuRDAList(new index_1.MuRDAList(new index_1.MuRDARegister(new schema_1.MuFloat64())));
const store = L.createStore([[1.11, 2.22, 3.33, 4.44, 5.55]]);
const dispatchers = L.action(store);
L.actionMeta.action.table.update;
const actions = [];
actions.push(dispatchers.update(0).splice(1, 2));
actions.push(dispatchers.update(0).shift());
actions.push(dispatchers.update(0).pop());
actions.push(dispatchers.update(0).unshift(1.11, 2.22));
actions.push(dispatchers.update(0).push(5.55, 6.66));
actions.push(dispatchers.update(0).splice(2, 0, 3.33));
actions.push(dispatchers.update(0).reset([11.1, 22.2, 33.3]));
actions.push(dispatchers.update(0).clear());
const inverses = [];
for (let i = 0; i < actions.length; ++i) {
const action = actions[i];
const inverse = store.inverse(L, action);
testInverse(t, store, L, action, JSON.stringify(action));
testInverse(t, store, L, inverse, JSON.stringify(inverse));
inverses.push(inverse);
}
t.end();
});
test('inverse - list of structs', (t) => {
const L = new index_1.MuRDAList(new index_1.MuRDAStruct({
f: new index_1.MuRDARegister(new schema_1.MuFloat64()),
u: new index_1.MuRDARegister(new schema_1.MuUTF8()),
s: new index_1.MuRDAStruct({
x: new index_1.MuRDARegister(new schema_1.MuFloat64()),
}),
}));
const store = L.createStore([L.valueRDA.stateSchema.identity]);
const dispatchers = L.action(store);
const actions = [];
actions.push(dispatchers.update(0).f(1));
actions.push(dispatchers.update(0).u('Iñtërnâtiônàlizætiøn☃💩'));
actions.push(dispatchers.update(0).s.x(0.5));
const inverses = [];
for (let i = 0; i < actions.length; ++i) {
const action = actions[i];
const inverse = store.inverse(L, actions[i]);
testInverse(t, store, L, action, JSON.stringify(action));
testInverse(t, store, L, inverse, JSON.stringify(inverse));
inverses.push(store.inverse(L, actions[i]));
}
for (let i = 0; i < actions.length; ++i) {
store.apply(L, actions[i]);
}
for (let i = 0; i < inverses.length; ++i) {
store.apply(L, inverses[i]);
}
t.deepEqual(store.state(L, []), [L.valueRDA.stateSchema.identity]);
t.end();
});
//# sourceMappingURL=inverse.js.map