int EntityRuleHandler::check(const Atlas::Objects::Root & desc)
{
if (desc->getObjtype() != "class") {
return -1;
}
return m_builder->isTask(desc->getParents().front()) ? -1 : 0;
}
int main()
{
ClientConnection * cc = new ClientConnection();
delete cc;
// Try all the method calls when not connected
cc = new ClientConnection();
cc->login("username", "password");
cc->create("player", "username", "password");
cc->wait();
{
Atlas::Objects::Operation::RootOperation op;
cc->send(op);
}
cc->pop();
cc->pending();
delete cc;
TestClientConnection * tcc = new TestClientConnection();
{
Atlas::Objects::Root obj;
Atlas::Objects::Operation::RootOperation op;
tcc->test_operation(op);
tcc->test_errorArrived(op);
tcc->test_infoArrived(op);
tcc->test_objectArrived(op);
Anonymous op_arg;
op->setArgs1(op_arg);
tcc->test_infoArrived(op);
op->setFrom("1");
tcc->test_infoArrived(op);
op->setParents(std::list<std::string>());
tcc->test_operation(op);
tcc->test_objectArrived(op);
Info i;
tcc->test_objectArrived(i);
Error e;
tcc->test_objectArrived(e);
tcc->test_objectArrived(obj);
obj->setParents(std::list<std::string>());
tcc->test_objectArrived(obj);
}
return 0;
}
int PropertyRuleHandler::check(const Atlas::Objects::Root & desc)
{
if (desc->getObjtype() != "type") {
return -1;
}
return 0;
}
int OpRuleHandler::check(const Atlas::Objects::Root & desc)
{
if (desc->getObjtype() != "op_definition") {
return -1;
}
return 0;
}
int ArchetypeRuleHandler::check(const Atlas::Objects::Root & desc)
{
if (desc->getObjtype() != "archetype") {
return -1;
}
return 0;
}
int EntityRuleHandler::check(const Atlas::Objects::Root & desc)
{
if (desc->getObjtype() != "class") {
return -1;
}
return 0;
}
void EntityImporterBase::createRule(const Atlas::Objects::Root & obj, OpVector & res)
{
m_state = RULE_CREATING;
Atlas::Objects::Operation::Create createOp;
createOp->setFrom(mAccountId);
createOp->setArgs1(obj);
createOp->setSerialno(newSerialNumber());
S_LOG_INFO("Creating new rule '" << obj->getId() << "' on server.");
res.push_back(createOp);
}
const Atlas::Objects::Root & Inheritance::getClass(const std::string & parent)
{
switch (stub_getclass_returns) {
case NULLCLASS:
return *new Atlas::Objects::Root(0);;
break;
case OAKCLASS:
{
Atlas::Objects::Root oak;
oak->setId("oak");
oak->setParents(std::list<std::string>(1, "game_entity"));
return *new Atlas::Objects::Root(oak);
}
break;
case NOCLASS:
default:
return noClass;
break;
}
}
int OpRuleHandler::installOpDefinition(const std::string & class_name,
const std::string & parent,
const Atlas::Objects::Root & class_desc,
std::string & dependent,
std::string & reason)
{
assert(class_name == class_desc->getId());
Inheritance & i = Inheritance::instance();
if (!i.hasClass(parent)) {
debug(std::cout << "op_definition \"" << class_name
<< "\" has non existant parent \"" << parent
<< "\". Waiting." << std::endl << std::flush;);
void EmberEntity::onImaginary(const Atlas::Objects::Root& act)
{
Atlas::Message::Element attr;
if (act->copyAttr("description", attr) && attr.isString()) {
std::string message = getName() + " " + attr.asString() + ".";
ConsoleBackend::getSingletonPtr()->pushMessage(message, "info");
S_LOG_VERBOSE("Entity: " << this->getId() << " (" << this->getName() << ") imaginary: " << attr.String());
}
Entity::onImaginary(act);
}
int main()
{
{
AtlasStreamClient * asc = new AtlasStreamClient;
delete asc;
}
TestAtlasStreamClient * asc = new TestAtlasStreamClient;
{
Atlas::Objects::Root obj;
asc->test_objectArrived(obj);
obj->setParents(std::list<std::string>());
asc->test_objectArrived(obj);
obj->setParents(std::list<std::string>(1, "foo"));
asc->test_objectArrived(obj);
obj->setObjtype("foo");
asc->test_objectArrived(obj);
}
Operation op;
asc->test_objectArrived(op);
asc->test_operation(op);
TestClientTask * tct = new TestClientTask();
// Test starting a task
asc->runTask(tct, "foo");
assert(asc->test_currentTask() == tct);
// Try and start it again will busy, as one is running
asc->runTask(new TestClientTask(), "foo");
assert(asc->test_currentTask() == tct);
asc->endTask();
assert(asc->test_currentTask() == 0);
asc->endTask();
assert(asc->test_currentTask() == 0);
tct = new TestClientTask();
asc->runTask(tct, "foo");
// Pass in an operation while a task is running.
asc->test_operation(op);
assert(asc->test_currentTask() == tct);
tct->make_complete();
asc->test_operation(op);
assert(asc->test_currentTask() == 0);
tct = new TestClientTask();
asc->runTask(tct, "foo");
assert(asc->test_currentTask() == tct);
// Pass in an operation while a task is running.
asc->test_operation(op);
assert(asc->test_currentTask() == tct);
{
Atlas::Objects::Operation::Info op;
asc->test_operation(op);
Atlas::Objects::Entity::Anonymous arg;
op->setArgs1(arg);
asc->test_operation(op);
op->setRefno(23);
asc->test_operation(op);
op->setRefno(asc->newSerialNo());
asc->test_operation(op);
op->setFrom("1");
asc->test_operation(op);
}
{
Atlas::Objects::Operation::Error op;
asc->test_operation(op);
Atlas::Objects::Entity::Anonymous arg;
op->setArgs1(arg);
asc->test_operation(op);
arg->setAttr("message", 1);
asc->test_operation(op);
arg->setAttr("message", "Real message");
asc->test_operation(op);
}
{
Atlas::Objects::Operation::Appearance op;
asc->test_operation(op);
}
{
Atlas::Objects::Operation::Disappearance op;
asc->test_operation(op);
}
{
Atlas::Objects::Operation::Sight op;
asc->test_operation(op);
}
{
Atlas::Objects::Operation::Sound op;
asc->test_operation(op);
}
assert(asc->test_currentTask() == tct);
// Verify these bale out cleanly when unconnected
asc->poll();
asc->login("foo", "bar");
asc->create("player", "foo", "bar");
int ret = asc->connect("localhost", 2323);
assert(ret != 0);
ret = asc->connectLocal("/sys/thereisnofilehere");
assert(ret != 0);
}
virtual void send(const Atlas::Objects::Root &obj) {
std::cout << "Sending " << obj->getParents().front()
<< std::endl << std::flush;
}
int TaskRuleHandler::check(const Atlas::Objects::Root & desc)
{
return m_builder->isTask(desc->getParents().front()) ? 0 : -1;
}
int main()
{
{
Juncture * j = new Juncture(0, "1", 1);
delete j;
}
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Operation op;
j->operation(op, res);
delete j;
}
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Atlas::Objects::Operation::Login op;
j->operation(op, res);
delete j;
}
// Login op, no args
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Operation op;
j->LoginOperation(op, res);
delete j;
}
// Login op, empty arg
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Operation op;
Atlas::Objects::Root arg;
op->setArgs1(arg);
j->LoginOperation(op, res);
delete j;
}
// Login op, username in arg
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Operation op;
Atlas::Objects::Root arg;
arg->setAttr("username", "69e362c6-03a4-11e0-9608-001ec93e7c08");
op->setArgs1(arg);
j->LoginOperation(op, res);
delete j;
}
// Login op, bad username in arg
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Operation op;
Atlas::Objects::Root arg;
arg->setAttr("username", 0x69e362c6);
op->setArgs1(arg);
j->LoginOperation(op, res);
delete j;
}
// Login op, username & password in arg
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Operation op;
Atlas::Objects::Root arg;
arg->setAttr("username", "69e362c6-03a4-11e0-9608-001ec93e7c08");
arg->setAttr("password", "a12a2f3a-03a4-11e0-8379-001ec93e7c08");
op->setArgs1(arg);
j->LoginOperation(op, res);
delete j;
}
// Login op, username & bad password in arg
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Operation op;
Atlas::Objects::Root arg;
arg->setAttr("username", "69e362c6-03a4-11e0-9608-001ec93e7c08");
arg->setAttr("password", 0x12a2f3aL);
op->setArgs1(arg);
j->LoginOperation(op, res);
delete j;
}
// Login op, username & password in arg, connected
{
ServerRouting sr(*(BaseWorld*)0, "", "", "2", 2, "3", 3);
CommServer cs;
TestJuncture * j = new TestJuncture(0);
CommPeer * cp = new CommPeer(cs, "");
j->test_addPeer(new Peer(*cp, sr, "", 6767, "4", 4));
OpVector res;
Operation op;
Atlas::Objects::Root arg;
arg->setAttr("username", "69e362c6-03a4-11e0-9608-001ec93e7c08");
arg->setAttr("password", "a12a2f3a-03a4-11e0-8379-001ec93e7c08");
op->setArgs1(arg);
j->LoginOperation(op, res);
delete j;
}
// Login op, username & password in arg, connected already authenticating
{
ServerRouting sr(*(BaseWorld*)0, "", "", "2", 2, "3", 3);
CommServer cs;
TestJuncture * j = new TestJuncture(0);
CommPeer * cp = new CommPeer(cs, "");
Peer * p = new Peer(*cp, sr, "", 6767, "4", 4);
j->test_addPeer(p);
p->setAuthState(PEER_AUTHENTICATING);
OpVector res;
Operation op;
Atlas::Objects::Root arg;
arg->setAttr("username", "69e362c6-03a4-11e0-9608-001ec93e7c08");
arg->setAttr("password", "a12a2f3a-03a4-11e0-8379-001ec93e7c08");
op->setArgs1(arg);
j->LoginOperation(op, res);
delete j;
}
// Login op, username & password in arg, connected, with serialno
{
ServerRouting sr(*(BaseWorld*)0, "", "", "2", 2, "3", 3);
CommServer cs;
TestJuncture * j = new TestJuncture(0);
CommPeer * cp = new CommPeer(cs, "");
j->test_addPeer(new Peer(*cp, sr, "", 6767, "4", 4));
OpVector res;
Operation op;
Atlas::Objects::Root arg;
arg->setAttr("username", "69e362c6-03a4-11e0-9608-001ec93e7c08");
arg->setAttr("password", "a12a2f3a-03a4-11e0-8379-001ec93e7c08");
op->setArgs1(arg);
op->setSerialno(0x6dc5b5eaL);
j->LoginOperation(op, res);
delete j;
}
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Operation op;
j->OtherOperation(op, res);
delete j;
}
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Atlas::Objects::Operation::Connect op;
j->OtherOperation(op, res);
delete j;
}
// Connect op, no args
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Operation op;
j->customConnectOperation(op, res);
delete j;
}
// Connect op, no args, already connected
{
TestJuncture * j = new TestJuncture(0);
j->test_addPeer(new Peer(*(CommPeer*)0, *(ServerRouting*)0, "", 6767, "4", 4));
OpVector res;
Operation op;
j->customConnectOperation(op, res);
delete j;
}
// Connect op, hostname in arg
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Operation op;
Atlas::Objects::Root arg;
arg->setAttr("hostname", "3752ca4a-03a9-11e0-bd8a-001ec93e7c08");
op->setArgs1(arg);
j->customConnectOperation(op, res);
delete j;
}
// Connect op, bad hostname in arg
{
Juncture * j = new Juncture(0, "1", 1);
OpVector res;
Operation op;
Atlas::Objects::Root arg;
arg->setAttr("hostname", 0x3752ca4aL);
op->setArgs1(arg);
j->customConnectOperation(op, res);
delete j;
}
// Connect op, hostname and port in arg, connected this end
{
ServerRouting sr(*(BaseWorld*)0, "", "", "2", 2, "3", 3);
CommServer cs;
CommSocket * cc = new StubSocket(cs, "", 23);
Connection * c = new Connection(*cc, sr, "", "4", 4);
Juncture * j = new Juncture(c, "1", 1);
OpVector res;
Operation op;
Atlas::Objects::Root arg;
arg->setAttr("hostname", "3752ca4a-03a9-11e0-bd8a-001ec93e7c08");
arg->setAttr("port", 0x03a9);
op->setArgs1(arg);
j->customConnectOperation(op, res);
delete j;
}
// Connect op, hostname and port in arg, connected this end, connect fails
{
stub_CommPeer_connect_return = -1;
ServerRouting sr(*(BaseWorld*)0, "", "", "2", 2, "3", 3);
CommServer cs;
CommSocket * cc = new StubSocket(cs, "", 23);
Connection * c = new Connection(*cc, sr, "", "4", 4);
Juncture * j = new Juncture(c, "1", 1);
OpVector res;
Operation op;
Atlas::Objects::Root arg;
arg->setAttr("hostname", "3752ca4a-03a9-11e0-bd8a-001ec93e7c08");
arg->setAttr("port", 0x03a9);
op->setArgs1(arg);
j->customConnectOperation(op, res);
stub_CommPeer_connect_return = 0;
delete j;
}
// Teleport unconnected
{
TestJuncture * j = new TestJuncture(0);
j->teleportEntity(0);
delete j;
}
// Teleport connected
{
TestJuncture * j = new TestJuncture(0);
j->test_addPeer(new Peer(*(CommPeer*)0, *(ServerRouting*)0, "", 6767, "4", 4));
j->teleportEntity(0);
delete j;
}
{
TestJuncture * j = new TestJuncture(0);
j->test_onPeerLost();
delete j;
}
// Peer replied, unconnected this end
{
TestJuncture * j = new TestJuncture(0);
Operation op;
j->test_onPeerReplied(op);
delete j;
}
// Peer replied, connected this end
{
Connection * c = new Connection(*(CommSocket*)0,
*(ServerRouting*)0, "", "4", 4);
TestJuncture * j = new TestJuncture(c);
Operation op;
j->test_onPeerReplied(op);
delete j;
}
return 0;
}
int main()
{
TestWorld world;
{
Entity e("2", 2);
ExternalMind em(e);
}
{
Entity e("2", 2);
TestExternalMind em(e);
em.test_deleteEntity("3");
}
// Purge with empty contains
{
Entity e("2", 2);
e.m_contains = new LocatedEntitySet;
TestExternalMind em(e);
em.test_purgeEntity(e);
}
// Purge with populated contains
{
Entity e("2", 2);
e.m_contains = new LocatedEntitySet;
e.m_contains->insert(new Entity("3", 3));
TestExternalMind em(e);
em.test_purgeEntity(e);
}
// Connect to nothing
{
Entity e("2", 2);
ExternalMind em(e);
em.linkUp(0);
}
// Connect to something
{
Entity e("2", 2);
ExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
}
// Connect to something, then disconnect
{
Entity e("2", 2);
ExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
em.linkUp(0);
}
// Connect to something, then check connection ID
{
Entity e("2", 2);
ExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
const std::string & id = em.connectionId();
assert(id == "4");
}
// Send a random operation
{
Entity e("2", 2);
TestExternalMind em(e);
em.test_setLossTime(BaseWorld::instance().getTime());
stub_baseworld_receieved_op = -1;
OpVector res;
em.operation(Atlas::Objects::Operation::RootOperation(), res);
assert(stub_baseworld_receieved_op == -1);
}
// Send a Delete operation
{
Entity e("2", 2);
TestExternalMind em(e);
em.test_setLossTime(BaseWorld::instance().getTime());
stub_baseworld_receieved_op = -1;
OpVector res;
em.operation(Atlas::Objects::Operation::Delete(), res);
assert(stub_baseworld_receieved_op == -1);
}
// Send a Delete operation to an ephemeral entity
{
Entity e("2", 2);
e.setFlags(entity_ephem);
TestExternalMind em(e);
em.test_setLossTime(BaseWorld::instance().getTime());
stub_baseworld_receieved_op = -1;
OpVector res;
em.operation(Atlas::Objects::Operation::Delete(), res);
assert(stub_baseworld_receieved_op == -1);
}
// Send a non Delete operation to an ephemeral entity
{
Entity e("2", 2);
e.setFlags(entity_ephem);
TestExternalMind em(e);
em.test_setLossTime(BaseWorld::instance().getTime());
stub_baseworld_receieved_op = -1;
OpVector res;
em.operation(Atlas::Objects::Operation::RootOperation(), res);
assert(stub_baseworld_receieved_op == Atlas::Objects::Operation::DELETE_NO);
}
// Send a random operation to something that has been recorded as
// disconnected for a while
{
Entity e("2", 2);
// FIXME hard code the expiry time here.
TestExternalMind em(e);
em.test_setLossTime(BaseWorld::instance().getTime() - 60*60 - 5);
stub_baseworld_receieved_op = -1;
OpVector res;
em.operation(Atlas::Objects::Operation::RootOperation(), res);
assert(stub_baseworld_receieved_op == Atlas::Objects::Operation::DELETE_NO);
}
// Send a random operation to a connected mind
{
Entity e("2", 2);
TestExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
stub_link_send_op = -1;
stub_link_send_count = 0;
OpVector res;
em.operation(Atlas::Objects::Operation::RootOperation(), res);
assert(stub_link_send_op == Atlas::Objects::Operation::ROOT_OPERATION_NO);
assert(stub_link_send_count == 1);
}
// Send a Sight operation to a connected mind
{
Entity e("2", 2);
TestExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
stub_link_send_op = -1;
stub_link_send_count = 0;
OpVector res;
em.operation(Atlas::Objects::Operation::Sight(), res);
assert(stub_link_send_op == Atlas::Objects::Operation::SIGHT_NO);
assert(stub_link_send_count == 1);
}
// Send a Sight(Set) of hungry operation to a connected mind
{
Entity e("2", 2);
TestExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
stub_link_send_op = -1;
stub_link_send_count = 0;
// A sight(set) of a starving entity
Atlas::Objects::Root arg;
arg->setAttr("status", 0.05);
arg->setId(e.getId());
Atlas::Objects::Operation::Set set;
set->setArgs1(arg);
Atlas::Objects::Operation::Sight op;
op->setArgs1(set);
// It should trigger an extra Sight(Imaginary)
OpVector res;
em.operation(op, res);
assert(stub_link_send_op == Atlas::Objects::Operation::SIGHT_NO);
assert(stub_link_send_count > 1);
}
// Send a Sight(Set) of starving operation to a connected mind
{
Entity e("2", 2);
TestExternalMind em(e);
em.linkUp(new Connection(*(CommSocket*)0,
*(ServerRouting*)0,
"addr", "4", 4));
stub_link_send_op = -1;
stub_link_send_count = 0;
// A sight(set) of a starving entity
Atlas::Objects::Root arg;
arg->setAttr("status", 0.005);
arg->setId(e.getId());
Atlas::Objects::Operation::Set set;
set->setArgs1(arg);
Atlas::Objects::Operation::Sight op;
op->setArgs1(set);
// It should trigger an extra Sight(Imaginary)
OpVector res;
em.operation(op, res);
assert(stub_link_send_op == Atlas::Objects::Operation::SIGHT_NO);
assert(stub_link_send_count > 1);
}
return 0;
}
int main()
{
TestWorld world;
CommServer server;
{
Peer * p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
delete p;
}
{
Peer * p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::RootOperation op;
OpVector res;
p->operation(op, res);
delete p;
}
{
// Test the setting of authentiaction states
Peer * p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
assert(p->getAuthState() == PEER_INIT);
p->setAuthState(PEER_AUTHENTICATED);
assert(p->getAuthState() == PEER_AUTHENTICATED);
delete p;
}
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Info op;
OpVector res;
p->operation(op, res);
}
// Authenticating (no args)
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATING);
Atlas::Objects::Operation::Info op;
OpVector res;
p->operation(op, res);
}
// Authenticating (empty arg)
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATING);
Atlas::Objects::Operation::Info op;
Atlas::Objects::Root arg;
op->setArgs1(arg);
OpVector res;
p->operation(op, res);
}
// Authenticating (full arg)
{
TestPeer *p = new TestPeer(*(CommSocket*)0, *(ServerRouting*)0, "addr", "1", 1);
p->setAuthState(PEER_AUTHENTICATING);
Atlas::Objects::Operation::Info op;
Atlas::Objects::Root arg;
arg->setId("2");
std::list<std::string> parents;
parents.push_back("server");
arg->setParents(parents);
op->setArgs1(arg);
OpVector res;
p->operation(op, res);
assert(p->getAccountType() == "server");
}
// Authenticated (no args)
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Atlas::Objects::Operation::Info op;
OpVector res;
p->operation(op, res);
}
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Error op;
OpVector res;
p->operation(op, res);
}
// Not authenticated
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Entity e("3", 3);
int ret = p->teleportEntity(&e);
assert(ret == -1);
}
// Authenticated
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Entity e("3", 3);
int ret = p->teleportEntity(&e);
assert(ret == 0);
assert(stub_CommClient_sent_op.isValid());
assert(stub_CommClient_sent_op->getArgs().size() == 1);
}
// Re-teleport same entity
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Entity e("3", 3);
int ret = p->teleportEntity(&e);
assert(ret == 0);
assert(stub_CommClient_sent_op.isValid());
assert(stub_CommClient_sent_op->getArgs().size() == 1);
ret = p->teleportEntity(&e);
assert(ret != 0);
}
// Character (no mind)
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Character e("3", 3);
int ret = p->teleportEntity(&e);
assert(ret == 0);
assert(stub_CommClient_sent_op.isValid());
assert(stub_CommClient_sent_op->getArgs().size() == 1);
}
// Character (externl mind, unconnected)
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Character e("3", 3);
e.m_externalMind = new ExternalMind(e);
int ret = p->teleportEntity(&e);
assert(ret == 0);
assert(stub_CommClient_sent_op.isValid());
assert(stub_CommClient_sent_op->getArgs().size() == 1);
}
// Character (externl mind, connected)
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Character e("3", 3);
ExternalMind * mind = new ExternalMind(e);
mind->linkUp((Link*)23);
e.m_externalMind = mind;
int ret = p->teleportEntity(&e);
assert(ret == 0);
assert(stub_CommClient_sent_op.isValid());
assert(stub_CommClient_sent_op->getArgs().size() == 2);
}
// No arg
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Info op;
OpVector res;
p->peerTeleportResponse(op, res);
}
// Empty arg, no refno
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
p->peerTeleportResponse(op, res);
}
// Empty arg, made up refno, not CommPeer
{
TestCommClient *peerConn = new TestCommClient(*(CommServer*)0, "name");
Peer *p = new Peer(*peerConn, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
op->setRefno(23);
p->peerTeleportResponse(op, res);
}
// Empty arg, made up refno
{
CommPeer *peerConn = new CommPeer(*(CommServer*)0, "name");
Peer *p = new Peer(*peerConn, *(ServerRouting*)0, "addr", 6767, "1", 1);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
op->setRefno(23);
p->peerTeleportResponse(op, res);
}
// Empty arg, refno that matches earlier teleport, not in world
{
CommPeer *peerConn = new CommPeer(server, "name");
Peer *p = new Peer(*peerConn, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Entity e("23", 23);
int ret = p->teleportEntity(&e);
assert(ret == 0);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
op->setRefno(23);
p->peerTeleportResponse(op, res);
}
// Empty arg, refno that matches earlier teleport, in world
{
CommPeer *peerConn = new CommPeer(server, "name");
Peer *p = new Peer(*peerConn, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Entity e("23", 23);
int ret = p->teleportEntity(&e);
assert(ret == 0);
world.test_addEntity(&e, 23);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
op->setRefno(23);
p->peerTeleportResponse(op, res);
world.test_delEntity(23);
}
// Empty arg, refno that matches earlier teleport, with mind
{
CommPeer *peerConn = new CommPeer(server, "name");
Peer *p = new Peer(*peerConn, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Character e("23", 23);
ExternalMind * mind = new ExternalMind(e);
mind->linkUp((Link*)23);
e.m_externalMind = mind;
int ret = p->teleportEntity(&e);
assert(ret == 0);
world.test_addEntity(&e, 23);
Atlas::Objects::Operation::Info op;
OpVector res;
Atlas::Objects::Root arg;
op->setArgs1(arg);
op->setRefno(23);
p->peerTeleportResponse(op, res);
world.test_delEntity(23);
}
// No teleports to clear
{
Peer *p = new Peer(*(CommSocket*)0, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->cleanTeleports();
}
// One teleport to clear
{
TestCommClient client(server, "");
Peer *p = new Peer(client, *(ServerRouting*)0, "addr", 6767, "1", 1);
p->setAuthState(PEER_AUTHENTICATED);
Entity e("23", 23);
int ret = p->teleportEntity(&e);
assert(ret == 0);
p->cleanTeleports();
}
return 0;
}