Пример #1
0
int main(void)
{
    init((CELL *)malloc(1024), 256);

    start_ass(EP);
    ass(O_LESS); ass(O_LESS); ass(O_LESS); ass(O_LESS);
    ass(O_GREATER); ass(O_GREATER); ass(O_GREATER); ass(O_GREATER);
    ass(O_EQUAL); ass(O_EQUAL); ass(O_NEQUAL); ass(O_NEQUAL);
    ass(O_LESS0); ass(O_LESS0); ass(O_LESS0); ass(O_GREATER0);
    ass(O_GREATER0); ass(O_GREATER0); ass(O_EQUAL0); ass(O_EQUAL0);
    ass(O_ULESS); ass(O_ULESS); ass(O_ULESS); ass(O_ULESS);
    ass(O_UGREATER); ass(O_UGREATER); ass(O_UGREATER); ass(O_UGREATER);

    assert(single_step() == -259);   // load first instruction word

    stack1();       // set up the stack with four standard pairs to compare
    step(0, 5);     // do the < tests
    stack1();
    step(5, 10);     // do the > tests
    stack2();       // set up the stack with two standard pairs to compare
    step(10, 12);   // do the = tests
    stack2();
    step(12, 15);   // do the <> tests
    stack3();       // set up the stack with three standard values
    step(15, 18);   // do the 0< tests
    stack3();
    step(18, 22);   // do the 0> tests
    SP = S0;  PUSH(237); PUSH(0);	// set up the stack with two values
    step(22, 25);   // do the 0= tests
    stack1();       // set up the stack with four standard pairs to compare
    step(25, 30);   // do the U< tests
    stack1();
    step(30, 35);   // do the U> tests

    assert(exception == 0);
    printf("Comparison tests ran OK\n");
    return 0;
}
Пример #2
0
void tst_QUndoGroup::setActive()
{
    QUndoGroup group;
    QUndoStack stack1(&group), stack2(&group);

    QCOMPARE(group.activeStack(), (QUndoStack*)0);
    QCOMPARE(stack1.isActive(), false);
    QCOMPARE(stack2.isActive(), false);

    QUndoStack stack3;
    QCOMPARE(stack3.isActive(), true);

    group.addStack(&stack3);
    QCOMPARE(stack3.isActive(), false);

    stack1.setActive();
    QCOMPARE(group.activeStack(), &stack1);
    QCOMPARE(stack1.isActive(), true);
    QCOMPARE(stack2.isActive(), false);
    QCOMPARE(stack3.isActive(), false);

    group.setActiveStack(&stack2);
    QCOMPARE(group.activeStack(), &stack2);
    QCOMPARE(stack1.isActive(), false);
    QCOMPARE(stack2.isActive(), true);
    QCOMPARE(stack3.isActive(), false);

    group.removeStack(&stack2);
    QCOMPARE(group.activeStack(), (QUndoStack*)0);
    QCOMPARE(stack1.isActive(), false);
    QCOMPARE(stack2.isActive(), true);
    QCOMPARE(stack3.isActive(), false);

    group.removeStack(&stack2);
    QCOMPARE(group.activeStack(), (QUndoStack*)0);
    QCOMPARE(stack1.isActive(), false);
    QCOMPARE(stack2.isActive(), true);
    QCOMPARE(stack3.isActive(), false);
}
Пример #3
0
void stack3() { stack2(); }
Пример #4
0
int main()
{
    {
        Stack<int> stack;
        stack.push( 1 );
        stack.push( 2 );
        stack.push( 3 );

        Stack<int> stack2( stack );
        assert( stack2.empty() == false );
        assert( stack2.pop() == 3 );
        assert( stack2.empty() == false );
        assert( stack2.pop() == 2 );
        assert( stack2.empty() == false );
        assert( stack2.pop() == 1 );
        assert( stack2.empty() == true );

        assert( stack.empty() == false );
        assert( stack.pop() == 3 );
        assert( stack.empty() == false );
        assert( stack.pop() == 2 );
        assert( stack.empty() == false );
        assert( stack.pop() == 1 );
        assert( stack.empty() == true );

    }

    {
        Stack<TMP> stack;
        stack.push( TMP(1) );
        stack.push( TMP(2) );
        stack.push( TMP(3) );

        assert( stack.empty() == false );
        assert( stack.pop().v == 3 );
        assert( stack.empty() == false );
        assert( stack.pop().v == 2 );
        assert( stack.empty() == false );
        assert( stack.pop().v == 1 );
        assert( stack.empty() == true );
    }

    {
        Stack<int> stack;
        stack.push( 1 );
        stack.push( 2 );
        stack.push( 3 );

        Stack<int> stack2;

        while ( !stack.empty() )
        {
            stack2.push( stack.pop() );
        }

        assert( stack2.empty() == false );
        assert( stack2.pop() == 1 );
        assert( stack2.pop() == 2 );
        assert( stack2.pop() == 3 );

    }

    {
        Queue<int> q;
        q.push( 1 );
        q.push( 2 );
        q.push( 3 );
        q.push( 4 );

        assert( q.empty() == false );
        assert( q.pop() == 1 );
        assert( q.pop() == 2 );
        assert( q.pop() == 3 );
        assert( q.pop() == 4 );
        assert( q.empty() == true );

        q.push( 1 );
        q.push( 2 );
        assert( q.pop() == 1 );
        q.push( 3 );
        assert( q.pop() == 2 );
        q.push( 4 );
        assert( q.pop() == 3 );
        assert( q.pop() == 4 );
        assert( q.empty() == true );




    }
}
Пример #5
0
static void stack1(void)
{
	stack2();
}