1 
use conjure_cp::ast::Metadata;
2 
use conjure_cp::ast::{Expression, Moo};
3 
use conjure_cp::essence_expr;
4 
use conjure_cp::matrix_expr;
5 
use conjure_cp_core::{domain_int, range};
6 
use defile as _;
7 

            

        

            

                8
            

            

                
            

            

                
#[test]

            

        

            

                9
            

            

                2
            

            

                
fn test_2plus2() {

            

        

            

                10
            

            

                2
            

            

                
    let expr = essence_expr!(2 + 2);

            

        

            

                11
            

            

                2
            

            

                
    assert_eq!(

            

        

            

                12
            

            

                
            

            

                
        expr,

            

        

            

                13
            

            

                2
            

            

                
        Expression::Sum(

            

        

            

                14
            

            

                2
            

            

                
            Metadata::new(),

            

        

            

                15
            

            

                2
            

            

                
            Moo::new(matrix_expr![

            

        

            

                16
            

            

                2
            

            

                
                Expression::Atomic(Metadata::new(), 2.into()),

            

        

            

                17
            

            

                2
            

            

                
                Expression::Atomic(Metadata::new(), 2.into());

            

        

            

                18
            

            

                2
            

            

                
                domain_int!(1..)

            

        

            

                19
            

            

                2
            

            

                
            ])

            

        

            

                20
            

            

                2
            

            

                
        )

            

        

            

                21
            

            

                
            

            

                
    );

            

        

            

                22
            

            

                2
            

            

                
}

            

        

            

                23
            

            

                
            

            

                

            

        

            

                24
            

            

                
            

            

                
#[test]

            

        

            

                25
            

            

                2
            

            

                
fn test_metavar_const() {

            

        

            

                26
            

            

                2
            

            

                
    let x = 4;

            

        

            

                27
            

            

                2
            

            

                
    let expr = essence_expr!(&x + 2);

            

        

            

                28
            

            

                2
            

            

                
    assert_eq!(

            

        

            

                29
            

            

                
            

            

                
        expr,

            

        

            

                30
            

            

                2
            

            

                
        Expression::Sum(

            

        

            

                31
            

            

                2
            

            

                
            Metadata::new(),

            

        

            

                32
            

            

                2
            

            

                
            Moo::new(matrix_expr![

            

        

            

                33
            

            

                2
            

            

                
                Expression::Atomic(Metadata::new(), 4.into()),

            

        

            

                34
            

            

                2
            

            

                
                Expression::Atomic(Metadata::new(), 2.into());

            

        

            

                35
            

            

                2
            

            

                
                domain_int!(1..)

            

        

            

                36
            

            

                2
            

            

                
            ])

            

        

            

                37
            

            

                2
            

            

                
        )

            

        

            

                38
            

            

                
            

            

                
    );

            

        

            

                39
            

            

                2
            

            

                
}