TEST_F(MemberAttributeTest, testInitialValues) {
                HazelcastServer instance(*g_srvFactory);
                std::auto_ptr<HazelcastClient> hazelcastClient(getNewClient());
                Cluster cluster = hazelcastClient->getCluster();
                std::vector<Member> members = cluster.getMembers();
                ASSERT_EQ(1U,members.size());
                Member &member = members[0];
                ASSERT_TRUE(member.lookupAttribute("intAttr"));
                ASSERT_EQ("211", *member.getAttribute("intAttr"));

                ASSERT_TRUE(member.lookupAttribute("boolAttr"));
                ASSERT_EQ("true", *member.getAttribute("boolAttr"));

                ASSERT_TRUE(member.lookupAttribute("byteAttr"));
                ASSERT_EQ("7", *member.getAttribute("byteAttr"));

                ASSERT_TRUE(member.lookupAttribute("doubleAttr"));
                ASSERT_EQ("2.0", *member.getAttribute("doubleAttr"));

                ASSERT_TRUE(member.lookupAttribute("floatAttr"));
                ASSERT_EQ("1.2", *member.getAttribute("floatAttr"));

                ASSERT_TRUE(member.lookupAttribute("shortAttr"));
                ASSERT_EQ("3", *member.getAttribute("shortAttr"));

                ASSERT_TRUE(member.lookupAttribute("strAttr"));
                ASSERT_EQ(std::string("strAttr"), *member.getAttribute("strAttr"));

                instance.shutdown();
            }
Ejemplo n.º 2
0
            TEST_F(ClusterTest, testClusterListeners) {
                HazelcastServer instance(*g_srvFactory);
                std::auto_ptr<HazelcastClient> hazelcastClient(getNewClient());
                Cluster cluster = hazelcastClient->getCluster();
                util::CountDownLatch memberAdded(1);
                util::CountDownLatch memberAddedInit(2);
                util::CountDownLatch memberRemoved(1);
                util::CountDownLatch memberRemovedInit(1);
                util::CountDownLatch attributeLatch(7);
                util::CountDownLatch attributeLatchInit(7);

                SampleInitialListener sampleInitialListener(memberAddedInit, attributeLatchInit, memberRemovedInit);
                SampleListenerInClusterTest sampleListener(memberAdded, attributeLatch, memberRemoved);

                cluster.addMembershipListener(&sampleInitialListener);
                cluster.addMembershipListener(&sampleListener);

                HazelcastServer instance2(*g_srvFactory);

                ASSERT_TRUE(attributeLatchInit.await(30));
                ASSERT_TRUE(attributeLatch.await(30));
                ASSERT_TRUE(memberAdded.await(30));
                ASSERT_TRUE(memberAddedInit.await(30));

                instance2.shutdown();

                ASSERT_TRUE(memberRemoved.await(30));
                ASSERT_TRUE(memberRemovedInit.await(30));

                instance.shutdown();

                cluster.removeMembershipListener(&sampleInitialListener);
                cluster.removeMembershipListener(&sampleListener);
            }
int SV_checkForNewClients()
{ // Returns the amount of new clients
	int count = 0;
	while (getNewClient())
	{
		count++;
	}
	return count;
}
Ejemplo n.º 4
0
void Server::update()
{
	while(run.load())
	{
		if(!getNewClient(listenSock))
		{
			break;
		}
	}
	WSACleanup();
}
 ClientTxnQueueTest::ClientTxnQueueTest()
 : instance(*g_srvFactory)
 , client(getNewClient()) {
 }
            ClientQueueTest::ClientQueueTest()
            : instance(*g_srvFactory)
            , client(getNewClient())
            , q(new IQueue< std::string>(client->getQueue< std::string >("clientQueueTest"))) {

            }