Use Symbols to store JS object references when serialising and delete ObjectIDCache
When serialising JS objects, we keep track of any encountered object,
and serialize it only once. Any further serialisation instead stores an
ID referring to the original object (essentially an opaque pointer).
The trouble of course is to have a unique, persistent identifier for
such an object.
svn uses an ObjectIDCache, essentially a "JS Object -> ID" map (which
internally is essentially a "JS heap pointer -> ID" map).
JS, since ES15, includes a "Symbol" primitive type, which is a unique,
immutable identifier. They are also not iterable by for..in or
GetOwnPropertyName or related.
This means they can be used to store the tag directly on the object
(since it's impossible overwrite a user property).
Thanks to this, we can forgo ObjectIDCache in the serializers, and since
following D2897 it becomes unused, we can delete it, along with the
Finalization code it used.
Part of SM52 migration, stage: SM45-compatible changes.
Patch by: Itms
Tested By: Freagarach
Refs #4893
Differential Revision: https://code.wildfiregames.com/D3085
This was SVN commit r24167.
2020-11-12 07:40:19 +01:00
|
|
|
/* Copyright (C) 2020 Wildfire Games.
|
2010-01-09 20:20:14 +01:00
|
|
|
* This file is part of 0 A.D.
|
|
|
|
*
|
|
|
|
* 0 A.D. is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* 0 A.D. is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "simulation2/system/ComponentTest.h"
|
|
|
|
|
|
|
|
#include "simulation2/components/ICmpCommandQueue.h"
|
|
|
|
|
|
|
|
class TestCmpCommandQueue : public CxxTest::TestSuite
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
void setUp()
|
|
|
|
{
|
|
|
|
CXeromyces::Startup();
|
|
|
|
}
|
|
|
|
|
|
|
|
void tearDown()
|
|
|
|
{
|
|
|
|
CXeromyces::Terminate();
|
|
|
|
}
|
|
|
|
|
|
|
|
void test_basic()
|
|
|
|
{
|
2014-04-25 23:19:51 +02:00
|
|
|
ComponentTestHelper test(g_ScriptRuntime);
|
2020-11-13 14:18:22 +01:00
|
|
|
ScriptInterface::Request rq(test.GetScriptInterface());
|
2010-01-09 20:20:14 +01:00
|
|
|
|
2010-05-20 02:59:01 +02:00
|
|
|
std::vector<SimulationCommand> empty;
|
|
|
|
|
2015-06-21 21:22:12 +02:00
|
|
|
ICmpCommandQueue* cmp = test.Add<ICmpCommandQueue>(CID_CommandQueue, "", SYSTEM_ENTITY);
|
2010-01-09 20:20:14 +01:00
|
|
|
|
|
|
|
TS_ASSERT(test.GetScriptInterface().Eval("var cmds = []; function ProcessCommand(player, cmd) { cmds.push([player, cmd]); }"));
|
|
|
|
|
2020-11-13 14:18:22 +01:00
|
|
|
JS::RootedValue cmd(rq.cx);
|
2010-01-09 20:20:14 +01:00
|
|
|
|
2015-01-24 15:46:52 +01:00
|
|
|
TS_ASSERT(test.GetScriptInterface().Eval("([1,2,3])", &cmd));
|
2010-05-20 02:59:01 +02:00
|
|
|
cmp->PushLocalCommand(1, cmd);
|
2010-01-09 20:20:14 +01:00
|
|
|
|
Use Symbols to store JS object references when serialising and delete ObjectIDCache
When serialising JS objects, we keep track of any encountered object,
and serialize it only once. Any further serialisation instead stores an
ID referring to the original object (essentially an opaque pointer).
The trouble of course is to have a unique, persistent identifier for
such an object.
svn uses an ObjectIDCache, essentially a "JS Object -> ID" map (which
internally is essentially a "JS heap pointer -> ID" map).
JS, since ES15, includes a "Symbol" primitive type, which is a unique,
immutable identifier. They are also not iterable by for..in or
GetOwnPropertyName or related.
This means they can be used to store the tag directly on the object
(since it's impossible overwrite a user property).
Thanks to this, we can forgo ObjectIDCache in the serializers, and since
following D2897 it becomes unused, we can delete it, along with the
Finalization code it used.
Part of SM52 migration, stage: SM45-compatible changes.
Patch by: Itms
Tested By: Freagarach
Refs #4893
Differential Revision: https://code.wildfiregames.com/D3085
This was SVN commit r24167.
2020-11-12 07:40:19 +01:00
|
|
|
TS_ASSERT(test.GetScriptInterface().Eval("({\"x\":4})", &cmd));
|
2010-05-20 02:59:01 +02:00
|
|
|
cmp->PushLocalCommand(-1, cmd);
|
2010-01-09 20:20:14 +01:00
|
|
|
|
|
|
|
test.Roundtrip();
|
|
|
|
|
|
|
|
// Process the first two commands
|
2010-05-20 02:59:01 +02:00
|
|
|
cmp->FlushTurn(empty);
|
2010-01-09 20:20:14 +01:00
|
|
|
|
Use Symbols to store JS object references when serialising and delete ObjectIDCache
When serialising JS objects, we keep track of any encountered object,
and serialize it only once. Any further serialisation instead stores an
ID referring to the original object (essentially an opaque pointer).
The trouble of course is to have a unique, persistent identifier for
such an object.
svn uses an ObjectIDCache, essentially a "JS Object -> ID" map (which
internally is essentially a "JS heap pointer -> ID" map).
JS, since ES15, includes a "Symbol" primitive type, which is a unique,
immutable identifier. They are also not iterable by for..in or
GetOwnPropertyName or related.
This means they can be used to store the tag directly on the object
(since it's impossible overwrite a user property).
Thanks to this, we can forgo ObjectIDCache in the serializers, and since
following D2897 it becomes unused, we can delete it, along with the
Finalization code it used.
Part of SM52 migration, stage: SM45-compatible changes.
Patch by: Itms
Tested By: Freagarach
Refs #4893
Differential Revision: https://code.wildfiregames.com/D3085
This was SVN commit r24167.
2020-11-12 07:40:19 +01:00
|
|
|
TS_ASSERT(test.GetScriptInterface().Eval("({\"y\":5})", &cmd));
|
2010-05-20 02:59:01 +02:00
|
|
|
cmp->PushLocalCommand(10, cmd);
|
2010-01-09 20:20:14 +01:00
|
|
|
|
|
|
|
// Process the next command
|
2010-05-20 02:59:01 +02:00
|
|
|
cmp->FlushTurn(empty);
|
2010-01-09 20:20:14 +01:00
|
|
|
|
|
|
|
// Process no commands
|
2010-05-20 02:59:01 +02:00
|
|
|
cmp->FlushTurn(empty);
|
2010-01-09 20:20:14 +01:00
|
|
|
|
|
|
|
test.Roundtrip();
|
|
|
|
|
|
|
|
std::string output;
|
Use Symbols to store JS object references when serialising and delete ObjectIDCache
When serialising JS objects, we keep track of any encountered object,
and serialize it only once. Any further serialisation instead stores an
ID referring to the original object (essentially an opaque pointer).
The trouble of course is to have a unique, persistent identifier for
such an object.
svn uses an ObjectIDCache, essentially a "JS Object -> ID" map (which
internally is essentially a "JS heap pointer -> ID" map).
JS, since ES15, includes a "Symbol" primitive type, which is a unique,
immutable identifier. They are also not iterable by for..in or
GetOwnPropertyName or related.
This means they can be used to store the tag directly on the object
(since it's impossible overwrite a user property).
Thanks to this, we can forgo ObjectIDCache in the serializers, and since
following D2897 it becomes unused, we can delete it, along with the
Finalization code it used.
Part of SM52 migration, stage: SM45-compatible changes.
Patch by: Itms
Tested By: Freagarach
Refs #4893
Differential Revision: https://code.wildfiregames.com/D3085
This was SVN commit r24167.
2020-11-12 07:40:19 +01:00
|
|
|
TS_ASSERT(test.GetScriptInterface().Eval("JSON.stringify(cmds)", output));
|
|
|
|
TS_ASSERT_STR_EQUALS(output, "[[1,[1,2,3]],[-1,{\"x\":4}],[10,{\"y\":5}]]");
|
2010-01-09 20:20:14 +01:00
|
|
|
}
|
|
|
|
};
|