expstdoptest.java

UML设计测试工具

        Expression[] args2;
        ExpStdOp op;
        ExpStdOp op1;
        ExpStdOp op2;
        args1 = new Expression[] { new ExpConstInteger(2), new ExpConstInteger(3)};
        op1 = ExpStdOp.create("mkSet", args1);
        args = new Expression[] { op1 };

        op = ExpStdOp.create("size", args);
        assertEquals(op.toString(), new IntegerValue(2), e.eval(op, state));

        op = ExpStdOp.create("isEmpty", args);
        assertEquals(op.toString(), BooleanValue.FALSE, e.eval(op, state));

        op = ExpStdOp.create("notEmpty", args);
        assertEquals(op.toString(), BooleanValue.TRUE, e.eval(op, state));

        args = new Expression[] { op1, new ExpConstInteger(3)};
        op = ExpStdOp.create("includes", args);
        assertEquals(op.toString(), BooleanValue.TRUE, e.eval(op, state));

        args = new Expression[] { op1, new ExpConstInteger(5)};
        op = ExpStdOp.create("includes", args);
        assertEquals(op.toString(), BooleanValue.FALSE, e.eval(op, state));

        args = new Expression[] { op1, new ExpConstInteger(3)};
        op = ExpStdOp.create("count", args);
        assertEquals(op.toString(), new IntegerValue(1), e.eval(op, state));

        args = new Expression[] { op1, new ExpConstInteger(5)};
        op = ExpStdOp.create("count", args);
        assertEquals(op.toString(), new IntegerValue(0), e.eval(op, state));

        args2 = new Expression[] { new ExpConstInteger(2), new ExpConstInteger(3)};
        op2 = ExpStdOp.create("mkSet", args2);
        args = new Expression[] { op1, op2 };
        op = ExpStdOp.create("includesAll", args);
        assertEquals(op.toString(), BooleanValue.TRUE, e.eval(op, state));

        args2 = new Expression[] { new ExpConstInteger(2)};
        op2 = ExpStdOp.create("mkSet", args2);
        args = new Expression[] { op1, op2 };
        op = ExpStdOp.create("includesAll", args);
        assertEquals(op.toString(), BooleanValue.TRUE, e.eval(op, state));

        args2 = new Expression[] { new ExpConstInteger(2), new ExpConstInteger(5)};
        op2 = ExpStdOp.create("mkSet", args2);
        args = new Expression[] { op1, op2 };
        op = ExpStdOp.create("includesAll", args);
        assertEquals(op.toString(), BooleanValue.FALSE, e.eval(op, state));
    }

    public void testSetOperations() throws ExpInvalidException {
        Expression[] args;
        Expression[] args1;
        Expression[] args2;
        ExpStdOp op;
        ExpStdOp op1;
        ExpStdOp op2;
        Value values[];
        args1 = new Expression[] { new ExpConstInteger(2), new ExpConstInteger(3)};
        op1 = ExpStdOp.create("mkSet", args1);
        args = new Expression[] { op1 };

        args2 = new Expression[] { new ExpConstInteger(2), new ExpConstInteger(5)};
        op2 = ExpStdOp.create("mkSet", args2);
        args = new Expression[] { op1, op2 };
        op = ExpStdOp.create("union", args);
        values =
            new Value[] { new IntegerValue(2), new IntegerValue(3), new IntegerValue(5)};
        assertEquals(
                     op.toString(),
                     new SetValue(TypeFactory.mkInteger(), values),
                     e.eval(op, state));

        args2 = new Expression[] { new ExpConstInteger(2), new ExpConstInteger(5)};
        op2 = ExpStdOp.create("mkSet", args2);
        args = new Expression[] { op1, op2 };
        op = ExpStdOp.create("intersection", args);
        values = new Value[] { new IntegerValue(2)};
        assertEquals(
                     op.toString(),
                     new SetValue(TypeFactory.mkInteger(), values),
                     e.eval(op, state));

        args2 = new Expression[] { new ExpConstInteger(4), new ExpConstInteger(5)};
        op2 = ExpStdOp.create("mkSet", args2);
        args = new Expression[] { op1, op2 };
        op = ExpStdOp.create("intersection", args);
        assertEquals(
                     op.toString(),
                     new SetValue(TypeFactory.mkInteger()),
                     e.eval(op, state));

        args2 = new Expression[] { new ExpConstInteger(2), new ExpConstInteger(5)};
        op2 = ExpStdOp.create("mkSet", args2);
        args = new Expression[] { op1, op2 };
        op = ExpStdOp.create("-", args);
        values = new Value[] { new IntegerValue(3)};
        assertEquals(
                     op.toString(),
                     new SetValue(TypeFactory.mkInteger(), values),
                     e.eval(op, state));

        args = new Expression[] { op1, new ExpConstInteger(8)};
        op = ExpStdOp.create("including", args);
        values =
            new Value[] { new IntegerValue(2), new IntegerValue(3), new IntegerValue(8)};
        assertEquals(
                     op.toString(),
                     new SetValue(TypeFactory.mkInteger(), values),
                     e.eval(op, state));

        args = new Expression[] { op1, new ExpConstInteger(3)};
        op = ExpStdOp.create("including", args);
        values = new Value[] { new IntegerValue(2), new IntegerValue(3)};
        assertEquals(
                     op.toString(),
                     new SetValue(TypeFactory.mkInteger(), values),
                     e.eval(op, state));

        args = new Expression[] { op1, new ExpConstInteger(8)};
        op = ExpStdOp.create("excluding", args);
        values = new Value[] { new IntegerValue(2), new IntegerValue(3)};
        assertEquals(
                     op.toString(),
                     new SetValue(TypeFactory.mkInteger(), values),
                     e.eval(op, state));

        args = new Expression[] { op1, new ExpConstInteger(3)};
        op = ExpStdOp.create("excluding", args);
        values = new Value[] { new IntegerValue(2)};
        assertEquals(
                     op.toString(),
                     new SetValue(TypeFactory.mkInteger(), values),
                     e.eval(op, state));

        args2 = new Expression[] { new ExpConstInteger(2), new ExpConstInteger(5)};
        op2 = ExpStdOp.create("mkSet", args2);
        args = new Expression[] { op1, op2 };
        op = ExpStdOp.create("symmetricDifference", args);
        values = new Value[] { new IntegerValue(3), new IntegerValue(5)};
        assertEquals(
                     op.toString(),
                     new SetValue(TypeFactory.mkInteger(), values),
                     e.eval(op, state));
    }

    public void testBagOperations() throws ExpInvalidException {
        Expression[] args;
        Expression[] args1;
        ExpStdOp op;
        ExpStdOp op1;
        Value values[];
        args1 =
            new Expression[] {
                new ExpConstInteger(2),
                new ExpConstInteger(3),
                new ExpConstInteger(2)};
        op1 = ExpStdOp.create("mkBag", args1);
        args = new Expression[] { op1 };
        op = ExpStdOp.create("asSet", args);
        values = new Value[] { new IntegerValue(2), new IntegerValue(3)};
        assertEquals(
                     op.toString(),
                     new SetValue(TypeFactory.mkInteger(), values),
                     e.eval(op, state));
    }

    public void testSequenceOperations() throws ExpInvalidException {
        Expression[] args;
        Expression[] args1;
        ExpStdOp op;
        ExpStdOp op1;

        args1 = new Expression[] { new ExpConstInteger(2), new ExpConstInteger(3)};
        op1 = ExpStdOp.create("mkSequence", args1);
        args = new Expression[] { op1, new ExpConstInteger(1)};
        op = ExpStdOp.create("at", args);
        assertEquals(op.toString(), e.eval(op, state), new IntegerValue(2));

        args = new Expression[] { op1, new ExpConstInteger(2)};
        op = ExpStdOp.create("at", args);
        assertEquals(op.toString(), e.eval(op, state), new IntegerValue(3));

        args = new Expression[] { op1, new ExpConstInteger(0)};
        op = ExpStdOp.create("at", args);
        assertEquals(
                     op.toString(),
                     e.eval(op, state),
                     new UndefinedValue(TypeFactory.mkInteger()));

        args = new Expression[] { op1, new ExpConstInteger(3)};
        op = ExpStdOp.create("at", args);
        assertEquals(
                     op.toString(),
                     e.eval(op, state),
                     new UndefinedValue(TypeFactory.mkInteger()));
    }

    public void testLargeSetsAndSequences() throws ExpInvalidException {
        Expression[] args;
        Expression[] args1;
        ExpStdOp op;
        ExpStdOp op1;

        final int SET_SIZE = 5000;
        args1 = new Expression[SET_SIZE];
        for (int i = 0; i < SET_SIZE; i++)
            args1[i] = new ExpConstInteger(i);
        op1 = ExpStdOp.create("mkSet", args1);
        args = new Expression[] { op1 };
        op = ExpStdOp.create("size", args);
        assertEquals(
                     "mkSet(0.." + SET_SIZE + ").size",
                     new IntegerValue(SET_SIZE),
                     e.eval(op, state));

        args1 = new Expression[SET_SIZE];
        for (int i = 0; i < SET_SIZE; i++)
            args1[i] = new ExpConstInteger(i);
        op1 = ExpStdOp.create("mkSequence", args1);
        args = new Expression[] { op1 };
        op = ExpStdOp.create("size", args);
        assertEquals(
                     "mkSequence(0.." + SET_SIZE + ").size",
                     new IntegerValue(SET_SIZE),
                     e.eval(op, state));
    }
}