TEST_F(P2pSessionTest, testUnicast)
{
TestRpcPlugIn* peerRpcPlugIn1;
TestP2pEventHandler peerEventHandler1;
boost::scoped_ptr<P2pSession> peer1(
P2pSessionFactory::create(2, peerEventHandler1));
peerRpcPlugIn1 = new TestRpcPlugIn;
PlugInPtr plugIn1(peerRpcPlugIn1);
peer1->attach(plugIn1);
EXPECT_TRUE(peer1->open(ACE_DEFAULT_SERVER_PORT + 1));
peer1->connect(getHostAddresses());
for (int i = 0; i < (2 * 3); ++i) {
peer1->tick();
hostSession_->tick();
}
TestRpcPlugIn* peerRpcPlugIn2;
TestP2pEventHandler peerEventHandler2;
boost::scoped_ptr<P2pSession> peer2(
P2pSessionFactory::create(3, peerEventHandler2));
peerRpcPlugIn2 = new TestRpcPlugIn;
PlugInPtr plugIn2(peerRpcPlugIn2);
peer2->attach(plugIn2);
EXPECT_TRUE(peer2->open(ACE_DEFAULT_SERVER_PORT + 2));
peer2->connect(getHostAddresses());
for (int i = 0; i < (2 * 4); ++i) {
peer1->tick();
peer2->tick();
hostSession_->tick();
}
EXPECT_EQ(int(hostSession_->getPeerCount()), int(peer1->getPeerCount()));
const PeerHint hint(2);
hostRpcPlugIn_->hello("hi", &hint);
for (int i = 0; i < (2 * 3); ++i) {
hostSession_->tick();
peer1->tick();
peer2->tick();
}
EXPECT_EQ("hi", peerRpcPlugIn1->getLastWorld());
EXPECT_EQ(PeerId(1), peerRpcPlugIn1->getLastPeerId());
EXPECT_EQ("", peerRpcPlugIn2->getLastWorld());
EXPECT_EQ(invalidPeerId, peerRpcPlugIn2->getLastPeerId());
}
TEST_F(P2pSessionTest, testCannotConnectPeerBeforeHostConnected)
{
TestP2pEventHandler peerEventHandler1;
boost::scoped_ptr<P2pSession> peer1(
P2pSessionFactory::create(2, peerEventHandler1));
EXPECT_TRUE(peer1->open(ACE_DEFAULT_SERVER_PORT + 1));
TestP2pEventHandler peerEventHandler2;
boost::scoped_ptr<P2pSession> peer2(
P2pSessionFactory::create(3, peerEventHandler2));
EXPECT_TRUE(peer2->open(ACE_DEFAULT_SERVER_PORT + 2));
peer1->connect(getHostAddresses());
for (int i = 0; i < (2 * 3); ++i) {
peer1->tick();
hostSession_->tick();
}
peer2->connect(peer1->getAddresses(2));
for (int i = 0; i < (2 * 3); ++i) {
peer1->tick();
peer2->tick();
hostSession_->tick();
}
EXPECT_EQ(2, int(hostSession_->getPeerCount()));
EXPECT_EQ(2, int(peer1->getPeerCount()));
}
TEST_F(P2pSessionTest, testLimitPeers)
{
const int maxPeers = 2;
hostSession_->close();
openHost("", maxPeers);
const int peerCount = 2;
P2pSession* peers[peerCount];
TestP2pEventHandler eventHandlers[peerCount];
for (int i = 0; i < peerCount; ++i) {
peers[i] = P2pSessionFactory::create(PeerId(2 + i), eventHandlers[i]);
EXPECT_TRUE(peers[i]->open(ACE_DEFAULT_SERVER_PORT + (u_short)i + 1)) <<
"#" << i << "peer";
peers[i]->connect(getHostAddresses());
}
for (int x = 0; x < (peerCount * 8); ++x) {
for (int i = 0; i < peerCount; ++i) {
peers[i]->tick();
}
hostSession_->tick();
}
EXPECT_EQ(maxPeers, int(hostSession_->getPeerCount()));
EXPECT_EQ(maxPeers - 1, int(hostEventHandler_.getConnectedPeers()));
for (int i = 0; i < peerCount; ++i) {
delete peers[i];
}
}
TEST_F(P2pSessionTest, testDisconnect)
{
TestP2pEventHandler peerEventHandler;
boost::scoped_ptr<P2pSession> peer(
P2pSessionFactory::create(2, peerEventHandler));
EXPECT_TRUE(peer->open(ACE_DEFAULT_SERVER_PORT + 1));
peer->connect(getHostAddresses());
for (int i = 0; i < (2 * 3); ++i) {
peer->tick();
hostSession_->tick();
}
EXPECT_EQ(int(hostSession_->getPeerCount()), int(peer->getPeerCount()));
peer->close();
for (int i = 0; i < 2 * 3; ++i) {
peer->tick();
hostSession_->tick();
}
EXPECT_EQ(0, int(hostEventHandler_.getConnectedPeers()));
EXPECT_EQ(1, int(hostSession_->getPeerCount()));
EXPECT_EQ(1, int(peerEventHandler.getConnectedPeers()));
EXPECT_EQ(0, int(peer->getPeerCount()));
}
void StartScene::printServerInfo() {
QStringList items = getHostAddresses();
items.sort();
foreach (const QString &item, items) {
if (item.startsWith("192.168.") || item.startsWith("10."))
server_log->append(tr("Your LAN address: %1, this address is available only for hosts that in the same LAN").arg(item));
else if (item.startsWith("172.")) {
QHostAddress address(item);
quint32 ipv4 = address.toIPv4Address();
if (ipv4 >= 0xAC100000 && ipv4 <= 0xAC1FFFFF) {
server_log->append(tr("Your LAN address: %1, this address is available only for hosts that in the same LAN").arg(item));
}
}
else if (item == "127.0.0.1")
server_log->append(tr("Your loopback address %1, this address is available only for your host").arg(item));
else if (item.startsWith("5."))
server_log->append(tr("Your Hamachi address: %1, the address is available for users that joined the same Hamachi network").arg(item));
else if (!item.startsWith("169.254."))
server_log->append(tr("Your other address: %1, if this is a public IP, that will be available for all cases").arg(item));
}
server_log->append(tr("Binding port number is %1").arg(Config.ServerPort));
server_log->append(tr("Game mode is %1").arg(Sanguosha->getModeName(Config.GameMode)));
server_log->append(tr("Player count is %1").arg(Sanguosha->getPlayerCount(Config.GameMode)));
server_log->append(Config.OperationNoLimit ?
tr("There is no time limit") :
tr("Operation timeout is %1 seconds").arg(Config.OperationTimeout));
server_log->append(Config.EnableCheat ? tr("Cheat is enabled") : tr("Cheat is disabled"));
if (Config.EnableCheat)
server_log->append(Config.FreeChoose ? tr("Free choose is enabled") : tr("Free choose is disabled"));
if (Config.Enable2ndGeneral) {
QString scheme_str;
switch (Config.MaxHpScheme) {
case 0: scheme_str = QString(tr("Sum - %1")).arg(Config.Scheme0Subtraction); break;
case 1: scheme_str = tr("Minimum"); break;
case 2: scheme_str = tr("Maximum"); break;
case 3: scheme_str = tr("Average"); break;
}
server_log->append(tr("Secondary general is enabled, max hp scheme is %1").arg(scheme_str));
} else
server_log->append(tr("Seconardary general is disabled"));
server_log->append(Config.EnableSame ?
tr("Same Mode is enabled") :
tr("Same Mode is disabled"));
server_log->append(Config.EnableBasara ?
tr("Basara Mode is enabled") :
tr("Basara Mode is disabled"));
server_log->append(Config.EnableHegemony ?
tr("Hegemony Mode is enabled") :
tr("Hegemony Mode is disabled"));
if (Config.EnableAI) {
server_log->append(tr("This server is AI enabled, AI delay is %1 milliseconds").arg(Config.AIDelay));
} else
server_log->append(tr("This server is AI disabled"));
}
TEST_F(P2pSessionTest, testOnePeerConnect)
{
TestP2pEventHandler peerEventHandler;
boost::scoped_ptr<P2pSession> peer(
P2pSessionFactory::create(2, peerEventHandler));
EXPECT_TRUE(peer->open(ACE_DEFAULT_SERVER_PORT + 1));
peer->connect(getHostAddresses());
for (int i = 0; i < (2 * 3); ++i) {
peer->tick();
hostSession_->tick();
}
EXPECT_EQ(2, int(hostSession_->getPeerCount())) << "host: two peer";
EXPECT_EQ(2, int(peer->getPeerCount())) << "peer: two peer";
EXPECT_TRUE(peerEventHandler.isConnected(1)) << "the host connected";
}
TEST_F(P2pSessionTest, testMultiplePeerConnect)
{
typedef boost::shared_ptr<P2pSession> P2pSessionPtr;
typedef std::vector<P2pSessionPtr> P2pSessions;
const int peerCount = 3;
P2pSessions peers;
peers.reserve(peerCount);
TestP2pEventHandler eventHandlers[peerCount];
for (int i = 0; i < peerCount; ++i) {
P2pSessionPtr peer(
P2pSessionFactory::create(PeerId(2 + i), eventHandlers[i]));
EXPECT_TRUE(peer->open(ACE_DEFAULT_SERVER_PORT + (u_short)i + 1)) <<
"#" << i << " peer";
peer->connect(getHostAddresses());
peer->tick();
peers.push_back(peer);
}
for (int x = 0; x < (peerCount * 8); ++x) {
for (int i = 0; i < peerCount; ++i) {
peers[i]->tick();
}
hostSession_->tick();
pause(1);
}
EXPECT_EQ(peerCount + 1, int(hostSession_->getPeerCount()));
EXPECT_EQ(peerCount, int(hostEventHandler_.getConnectedPeers())) <<
"host - connected peer count";
for (int i = 0; i < peerCount; ++i) {
EXPECT_EQ(peerCount + 1, int(peers[i]->getPeerCount())) <<
"#" << i << " peer";
const PeerStats stats = peers[i]->getStats(1);
EXPECT_EQ(peerCount, int(eventHandlers[i].getConnectedPeers())) <<
"#" << i << " peer - connected peer count";
}
}
TEST_F(P2pSessionTest, testConnectWithValidPassword)
{
const srpc::String password("12345");
hostSession_->close();
openHost(password);
TestP2pEventHandler peerEventHandler;
boost::scoped_ptr<P2pSession> peer(
P2pSessionFactory::create(2, peerEventHandler, p2pConfig_));
EXPECT_TRUE(peer->open(ACE_DEFAULT_SERVER_PORT + 1, password));
peer->connect(getHostAddresses());
const ACE_Time_Value startTime = ACE_OS::gettimeofday();
while ((ACE_OS::gettimeofday() - startTime).msec() < getConnectDelay()) {
peer->tick();
hostSession_->tick();
}
EXPECT_EQ(invalidPeerId, peerEventHandler.getConnectFailedPeerId()) <<
"connect succeeded";
}
