TEST(FixedStack, ConstructionTest)
{
	ConstructionTest::Reset();
	FixedStack<22, ConstructionTest> array;
	EXPECT_EQ(0, ConstructionTest::Count());
	for(int i = 0; i<10; i++)
	{
		array.push_front(ConstructionTest() );
		EXPECT_EQ(i+1, ConstructionTest::Count());
	}
}
void
Profiler::Merge(Profiler * profiler)
{
    MergeTree(&rootNode, &profiler->rootNode);
    if (profiler->timeStack.Count() > 1)
    {
        FixedStack<TimeEntry, MaxStackDepth> reverseStack;
        do
        {
            reverseStack.Push(*profiler->timeStack.Pop());
        }
        while (profiler->timeStack.Count() > 1);

        do
        {
            TimeEntry * entry = reverseStack.Pop();
            this->Push(*entry);
            profiler->timeStack.Push(*entry);
        }
        while (reverseStack.Count() != 0);
    }
}
Beispiel #3
0
TEST(Containers, Stack)
{
	FixedStack<20, int> stack;
	FixedStack<20, int> &cref = stack;

	EXPECT_TRUE(stack.empty());
	EXPECT_TRUE(cref.empty());
	EXPECT_EQ(stack.size(), 0);
	EXPECT_EQ(cref.size(), 0);
	EXPECT_TRUE(stack.push_front(100));
	EXPECT_FALSE(stack.empty());
	EXPECT_FALSE(cref.empty());
	EXPECT_EQ(stack.front(), 100);
	EXPECT_EQ(cref.front(), 100);
	EXPECT_TRUE(stack.pop_front());
	EXPECT_FALSE(stack.pop_front());
	EXPECT_TRUE(stack.empty());
	EXPECT_TRUE(cref.empty());

	EXPECT_TRUE(stack.push_front(200));
	EXPECT_TRUE(stack.push_front(300));
	EXPECT_EQ(stack.front(), 300);
	EXPECT_EQ(cref.front(), 300);
	EXPECT_EQ(stack.back(), 200);
	EXPECT_EQ(cref.back(), 200);
	EXPECT_EQ(stack.size(), 2);
	EXPECT_EQ(cref.size(), 2);

	stack.clear();
	EXPECT_EQ(stack.size(), 0);
	EXPECT_TRUE(stack.empty());

	for(unsigned i=0; i< stack.capacity(); i++)
		EXPECT_TRUE(stack.push_front(i));
	EXPECT_FALSE(stack.push_front(-1));

	for(unsigned i=0; i < stack.capacity(); i++)
	{
		EXPECT_EQ(stack[i], int(stack.capacity() - 1 - i));
		EXPECT_EQ(cref[i], int(cref.capacity() - 1 - i));
	}

	for(unsigned i=0; i < stack.capacity(); i++)
	{
		EXPECT_EQ(stack.front(), int(stack.capacity() - 1 - i));
		EXPECT_EQ(cref.front(), int(cref.capacity() - 1 - i));
		EXPECT_TRUE(stack.pop_front());
	}
}