open Cli_expect

let contract basename =
  "../../test/contracts/" ^ basename
let bad_contract basename =
  "../../test/contracts/negative/" ^ basename

let%expect_test _ =
  run_ligo_good [ "measure-contract" ; contract "coase.ligo" ; "main" ] ;
  [%expect {| 1668 bytes |}] ;

  run_ligo_good [ "measure-contract" ; contract "multisig.ligo" ; "main" ] ;
  [%expect {| 995 bytes |}] ;

  run_ligo_good [ "measure-contract" ; contract "multisig-v2.ligo" ; "main" ] ;
  [%expect {| 2512 bytes |}] ;

  run_ligo_good [ "measure-contract" ; contract "vote.mligo" ; "main" ] ;
  [%expect {| 582 bytes |}] ;

  run_ligo_good [ "measure-contract" ; contract "issue-184-combs.mligo" ; "main2" ] ;
  [%expect {| 369 bytes |}] ;

  run_ligo_good [ "compile-parameter" ; contract "coase.ligo" ; "main" ; "Buy_single (record card_to_buy = 1n end)" ] ;
  [%expect {| (Left (Left 1)) |}] ;

  run_ligo_good [ "compile-storage" ; contract "coase.ligo" ; "main" ; "record cards = (map end : cards) ; card_patterns = (map end : card_patterns) ; next_id = 3n ; end" ] ;
  [%expect {| (Pair (Pair {} {}) 3) |}] ;

  run_ligo_bad [ "compile-storage" ; contract "coase.ligo" ; "main" ; "Buy_single (record card_to_buy = 1n end)" ] ;
  [%expect {|
    ligo: error
    Provided storage type does not match contract storage type
    Bad types: expected record[card_patterns -> (type_operator: Map (nat,record[coefficient -> mutez , quantity -> nat])) ,
                               cards -> (type_operator: Map (nat,record[card_owner -> address , card_pattern -> nat])) ,
                               next_id -> nat] got sum[Buy_single -> record[card_to_buy -> nat] ,
                                                       Sell_single -> record[card_to_sell -> nat] ,
                                                       Transfer_single -> record[card_to_transfer -> nat ,
                                                                        destination -> address]]


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}] ;

  run_ligo_bad [ "compile-parameter" ; contract "coase.ligo" ; "main" ; "record cards = (map end : cards) ; card_patterns = (map end : card_patterns) ; next_id = 3n ; end" ] ;
  [%expect {|
    ligo: error
    Provided parameter type does not match contract parameter type
    Bad types: expected sum[Buy_single -> record[card_to_buy -> nat] ,
                            Sell_single -> record[card_to_sell -> nat] ,
                            Transfer_single -> record[card_to_transfer -> nat ,
                                                      destination -> address]] got record[card_patterns -> (type_operator: Map (nat,record[coefficient -> mutez , quantity -> nat])) ,
                                                                        cards -> (type_operator: Map (nat,record[card_owner -> address , card_pattern -> nat])) ,
                                                                        next_id -> nat]


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}] ;

  ()

let%expect_test _  =
  run_ligo_good [ "compile-storage" ; contract "timestamp.ligo" ; "main" ; "now" ; "--predecessor-timestamp" ; "2042-01-01T00:00:00Z" ] ;
  [%expect {| "2042-01-01T00:00:01Z" |}]

let%expect_test _ =
  run_ligo_good [ "compile-contract" ; contract "coase.ligo" ; "main" ] ;
  [%expect {|
{ parameter
    (or (or (nat %buy_single) (nat %sell_single))
        (pair %transfer_single (nat %card_to_transfer) (address %destination))) ;
  storage
    (pair (pair (map %card_patterns nat (pair (mutez %coefficient) (nat %quantity)))
                (map %cards nat (pair (address %card_owner) (nat %card_pattern))))
          (nat %next_id)) ;
  code { DUP ;
         CDR ;
         DIG 1 ;
         DUP ;
         DUG 2 ;
         CAR ;
         IF_LEFT
           { DUP ;
             IF_LEFT
               { DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 PAIR ;
                 DUP ;
                 CAR ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 CDR ;
                 DUP ;
                 CAR ;
                 CAR ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 GET ;
                 IF_NONE
                   { PUSH string "buy_single: No card pattern." ; FAILWITH }
                   { DUP ; DIP { DROP } } ;
                 PUSH nat 1 ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 CDR ;
                 ADD ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 CAR ;
                 MUL ;
                 AMOUNT ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 COMPARE ;
                 GT ;
                 IF { PUSH string "Not enough money" ; FAILWITH } { PUSH unit Unit } ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 PUSH nat 1 ;
                 DIG 4 ;
                 DUP ;
                 DUG 5 ;
                 CDR ;
                 ADD ;
                 SWAP ;
                 CAR ;
                 PAIR ;
                 DIG 4 ;
                 DUP ;
                 DUG 5 ;
                 DIG 5 ;
                 DUP ;
                 DUG 6 ;
                 CAR ;
                 CAR ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 DIG 8 ;
                 DUP ;
                 DUG 9 ;
                 SWAP ;
                 SOME ;
                 SWAP ;
                 UPDATE ;
                 DIP { DUP ; CDR ; SWAP ; CAR ; CDR } ;
                 PAIR ;
                 PAIR ;
                 DUP ;
                 CAR ;
                 CDR ;
                 DIG 7 ;
                 DUP ;
                 DUG 8 ;
                 SENDER ;
                 PAIR ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 CDR ;
                 SWAP ;
                 SOME ;
                 SWAP ;
                 UPDATE ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ;
                 SWAP ;
                 PAIR ;
                 PAIR ;
                 DUP ;
                 PUSH nat 1 ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 CDR ;
                 ADD ;
                 SWAP ;
                 CAR ;
                 PAIR ;
                 DUP ;
                 NIL operation ;
                 PAIR ;
                 DIP { DROP 12 } }
               { DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 PAIR ;
                 DUP ;
                 CAR ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 CDR ;
                 DUP ;
                 CAR ;
                 CDR ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 GET ;
                 IF_NONE
                   { PUSH string "sell_single: No card." ; FAILWITH }
                   { DUP ; DIP { DROP } } ;
                 SENDER ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 CAR ;
                 COMPARE ;
                 NEQ ;
                 IF { PUSH string "This card doesn't belong to you" ; FAILWITH }
                    { PUSH unit Unit } ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 CAR ;
                 CAR ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 CDR ;
                 GET ;
                 IF_NONE
                   { PUSH string "sell_single: No card pattern." ; FAILWITH }
                   { DUP ; DIP { DROP } } ;
                 DUP ;
                 PUSH nat 1 ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 CDR ;
                 SUB ;
                 ABS ;
                 SWAP ;
                 CAR ;
                 PAIR ;
                 DIG 4 ;
                 DUP ;
                 DUG 5 ;
                 DIG 5 ;
                 DUP ;
                 DUG 6 ;
                 CAR ;
                 CAR ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 DIG 6 ;
                 DUP ;
                 DUG 7 ;
                 CDR ;
                 SWAP ;
                 SOME ;
                 SWAP ;
                 UPDATE ;
                 DIP { DUP ; CDR ; SWAP ; CAR ; CDR } ;
                 PAIR ;
                 PAIR ;
                 DUP ;
                 CAR ;
                 CDR ;
                 DIG 7 ;
                 DUP ;
                 DUG 8 ;
                 NONE (pair address nat) ;
                 SWAP ;
                 UPDATE ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 CDR ;
                 DIG 3 ;
                 DUP ;
                 DUG 4 ;
                 CAR ;
                 MUL ;
                 SENDER ;
                 CONTRACT unit ;
                 IF_NONE
                   { PUSH string "sell_single: No contract." ; FAILWITH }
                   { DUP ; DIP { DROP } } ;
                 DUP ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 UNIT ;
                 TRANSFER_TOKENS ;
                 NIL operation ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 CONS ;
                 DIG 5 ;
                 DUP ;
                 DUG 6 ;
                 DIG 5 ;
                 DUP ;
                 DUG 6 ;
                 DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ;
                 SWAP ;
                 PAIR ;
                 PAIR ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 PAIR ;
                 DIP { DROP 14 } } ;
             DIP { DROP } }
           { DIG 1 ;
             DUP ;
             DUG 2 ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             PAIR ;
             DUP ;
             CAR ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             CDR ;
             DUP ;
             CAR ;
             CDR ;
             DUP ;
             DIG 3 ;
             DUP ;
             DUG 4 ;
             CAR ;
             GET ;
             IF_NONE
               { PUSH string "transfer_single: No card." ; FAILWITH }
               { DUP ; DIP { DROP } } ;
             SENDER ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             CAR ;
             COMPARE ;
             NEQ ;
             IF { PUSH string "This card doesn't belong to you" ; FAILWITH }
                { PUSH unit Unit } ;
             DIG 3 ;
             DUP ;
             DUG 4 ;
             DIG 3 ;
             DUP ;
             DUG 4 ;
             DIG 3 ;
             DUP ;
             DUG 4 ;
             DIG 7 ;
             DUP ;
             DUG 8 ;
             CDR ;
             SWAP ;
             CDR ;
             SWAP ;
             PAIR ;
             DIG 7 ;
             DUP ;
             DUG 8 ;
             CAR ;
             SWAP ;
             SOME ;
             SWAP ;
             UPDATE ;
             DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ;
             SWAP ;
             PAIR ;
             PAIR ;
             NIL operation ;
             PAIR ;
             DIP { DROP 7 } } ;
         DIP { DROP 2 } } } |} ]

let%expect_test _ =
  run_ligo_good [ "compile-contract" ; contract "multisig.ligo" ; "main" ] ;
  [%expect {|
{ parameter
    (pair (pair (nat %counter) (lambda %message unit (list operation)))
          (list %signatures (pair key_hash signature))) ;
  storage
    (pair (pair (list %auth key) (nat %counter)) (pair (string %id) (nat %threshold))) ;
  code { DUP ;
         CAR ;
         DIG 1 ;
         DUP ;
         DUG 2 ;
         CDR ;
         DIG 1 ;
         DUP ;
         DUG 2 ;
         CAR ;
         CDR ;
         DIG 1 ;
         DUP ;
         DUG 2 ;
         CAR ;
         CDR ;
         DIG 3 ;
         DUP ;
         DUG 4 ;
         CAR ;
         CAR ;
         COMPARE ;
         NEQ ;
         IF { PUSH string "Counters does not match" ; FAILWITH }
            { CHAIN_ID ;
              DIG 2 ;
              DUP ;
              DUG 3 ;
              CDR ;
              CAR ;
              PAIR ;
              DIG 3 ;
              DUP ;
              DUG 4 ;
              CAR ;
              CAR ;
              DIG 2 ;
              DUP ;
              DUG 3 ;
              PAIR ;
              PAIR ;
              PACK ;
              PUSH nat 0 ;
              DIG 3 ;
              DUP ;
              DUG 4 ;
              CAR ;
              CAR ;
              PAIR ;
              DIG 4 ;
              DUP ;
              DUG 5 ;
              CDR ;
              ITER { SWAP ;
                     PAIR ;
                     DUP ;
                     CAR ;
                     CDR ;
                     DIG 1 ;
                     DUP ;
                     DUG 2 ;
                     CAR ;
                     CAR ;
                     DIG 2 ;
                     DUP ;
                     DUG 3 ;
                     CDR ;
                     DIG 2 ;
                     DUP ;
                     DUG 3 ;
                     DIG 2 ;
                     DUP ;
                     DUG 3 ;
                     PAIR ;
                     DIG 2 ;
                     DUP ;
                     DUG 3 ;
                     IF_CONS
                       { DUP ;
                         HASH_KEY ;
                         DIG 4 ;
                         DUP ;
                         DUG 5 ;
                         CAR ;
                         COMPARE ;
                         EQ ;
                         IF { DIG 7 ;
                              DUP ;
                              DUG 8 ;
                              DIG 4 ;
                              DUP ;
                              DUG 5 ;
                              CDR ;
                              DIG 2 ;
                              DUP ;
                              DUG 3 ;
                              CHECK_SIGNATURE ;
                              IF { PUSH nat 1 ;
                                   DIG 6 ;
                                   DUP ;
                                   DUG 7 ;
                                   ADD ;
                                   DIG 6 ;
                                   DUP ;
                                   DUG 7 ;
                                   DIG 1 ;
                                   DUP ;
                                   DUG 2 ;
                                   DIP { DROP 2 } }
                                 { PUSH string "Invalid signature" ; FAILWITH } ;
                              DIG 6 ;
                              DUP ;
                              DUG 7 ;
                              DIG 1 ;
                              DUP ;
                              DUG 2 ;
                              DIP { DROP 2 } }
                            { DIG 5 ; DUP ; DUG 6 } ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         DIG 3 ;
                         DUP ;
                         DUG 4 ;
                         SWAP ;
                         CDR ;
                         SWAP ;
                         PAIR ;
                         DIG 1 ;
                         DUP ;
                         DUG 2 ;
                         SWAP ;
                         CAR ;
                         PAIR ;
                         DIP { DROP 3 } }
                       { DUP } ;
                     DIG 5 ;
                     DUP ;
                     DUG 6 ;
                     DIG 1 ;
                     DUP ;
                     DUG 2 ;
                     CAR ;
                     DIP { DUP ; CDR ; SWAP ; CAR ; CDR } ;
                     PAIR ;
                     PAIR ;
                     DIG 1 ;
                     DUP ;
                     DUG 2 ;
                     CDR ;
                     DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ;
                     SWAP ;
                     PAIR ;
                     PAIR ;
                     CAR ;
                     DIP { DROP 6 } } ;
              DIG 3 ;
              DUP ;
              DUG 4 ;
              CDR ;
              CDR ;
              DIG 1 ;
              DUP ;
              DUG 2 ;
              CDR ;
              COMPARE ;
              LT ;
              IF { PUSH string "Not enough signatures passed the check" ; FAILWITH }
                 { DIG 3 ;
                   DUP ;
                   DUG 4 ;
                   PUSH nat 1 ;
                   DIG 5 ;
                   DUP ;
                   DUG 6 ;
                   CAR ;
                   CDR ;
                   ADD ;
                   DIP { DUP ; CDR ; SWAP ; CAR ; CAR } ;
                   SWAP ;
                   PAIR ;
                   PAIR ;
                   DIG 4 ;
                   DUP ;
                   DUG 5 ;
                   DIG 1 ;
                   DUP ;
                   DUG 2 ;
                   DIP { DROP 2 } } ;
              DIG 4 ;
              DUP ;
              DUG 5 ;
              DIG 1 ;
              DUP ;
              DUG 2 ;
              DIP { DROP 4 } } ;
         DUP ;
         UNIT ;
         DIG 3 ;
         DUP ;
         DUG 4 ;
         SWAP ;
         EXEC ;
         PAIR ;
         DIP { DROP 5 } } } |} ]

let%expect_test _ =
  run_ligo_good [ "compile-contract" ; contract "multisig-v2.ligo" ; "main" ] ;
  [%expect {|
{ parameter
    (or (or (unit %default) (lambda %send bytes (list operation)))
        (lambda %withdraw bytes (list operation))) ;
  storage
    (pair (pair (pair (set %authorized_addresses address) (nat %max_message_size))
                (pair (nat %max_proposal) (map %message_store bytes (set address))))
          (pair (pair (map %proposal_counters address nat) (bytes %state_hash))
                (nat %threshold))) ;
  code { DUP ;
         CDR ;
         DIG 1 ;
         DUP ;
         DUG 2 ;
         CAR ;
         IF_LEFT
           { DUP ;
             IF_LEFT
               { DIG 2 ; DUP ; DUG 3 ; NIL operation ; PAIR ; DIP { DROP } }
               { DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 PAIR ;
                 DUP ;
                 CDR ;
                 DUP ;
                 CAR ;
                 CAR ;
                 CAR ;
                 SENDER ;
                 MEM ;
                 NOT ;
                 IF { PUSH string "Unauthorized address" ; FAILWITH } { PUSH unit Unit } ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 CAR ;
                 DUP ;
                 PACK ;
                 DIG 3 ;
                 DUP ;
                 DUG 4 ;
                 CAR ;
                 CAR ;
                 CDR ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 SIZE ;
                 COMPARE ;
                 GT ;
                 IF { PUSH string "Message size exceed maximum limit" ; FAILWITH }
                    { PUSH unit Unit } ;
                 EMPTY_SET address ;
                 DIG 5 ;
                 DUP ;
                 DUG 6 ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 PAIR ;
                 DIG 6 ;
                 DUP ;
                 DUG 7 ;
                 CAR ;
                 CDR ;
                 CDR ;
                 DIG 4 ;
                 DUP ;
                 DUG 5 ;
                 GET ;
                 IF_NONE
                   { DIG 6 ;
                     DUP ;
                     DUG 7 ;
                     DIG 7 ;
                     DUP ;
                     DUG 8 ;
                     CDR ;
                     CAR ;
                     CAR ;
                     PUSH nat 1 ;
                     DIG 9 ;
                     DUP ;
                     DUG 10 ;
                     CDR ;
                     CAR ;
                     CAR ;
                     SENDER ;
                     GET ;
                     IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
                     ADD ;
                     SOME ;
                     SENDER ;
                     UPDATE ;
                     DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ;
                     PAIR ;
                     PAIR ;
                     SWAP ;
                     PAIR ;
                     EMPTY_SET address ;
                     PUSH bool True ;
                     SENDER ;
                     UPDATE ;
                     DIG 2 ;
                     DUP ;
                     DUG 3 ;
                     DIG 2 ;
                     DUP ;
                     DUG 3 ;
                     SWAP ;
                     CAR ;
                     PAIR ;
                     DIG 1 ;
                     DUP ;
                     DUG 2 ;
                     SWAP ;
                     CDR ;
                     SWAP ;
                     PAIR ;
                     DIP { DROP 2 } }
                   { DUP ;
                     SENDER ;
                     MEM ;
                     IF { DIG 7 ; DUP ; DUG 8 }
                        { DIG 7 ;
                          DUP ;
                          DUG 8 ;
                          DIG 8 ;
                          DUP ;
                          DUG 9 ;
                          CDR ;
                          CAR ;
                          CAR ;
                          PUSH nat 1 ;
                          DIG 10 ;
                          DUP ;
                          DUG 11 ;
                          CDR ;
                          CAR ;
                          CAR ;
                          SENDER ;
                          GET ;
                          IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
                          ADD ;
                          SOME ;
                          SENDER ;
                          UPDATE ;
                          DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ;
                          PAIR ;
                          PAIR ;
                          SWAP ;
                          PAIR ;
                          DIG 8 ;
                          DUP ;
                          DUG 9 ;
                          DIG 1 ;
                          DUP ;
                          DUG 2 ;
                          DIP { DROP 2 } } ;
                     DIG 1 ;
                     DUP ;
                     DUG 2 ;
                     PUSH bool True ;
                     SENDER ;
                     UPDATE ;
                     DIG 3 ;
                     DUP ;
                     DUG 4 ;
                     DIG 2 ;
                     DUP ;
                     DUG 3 ;
                     SWAP ;
                     CAR ;
                     PAIR ;
                     DIG 1 ;
                     DUP ;
                     DUG 2 ;
                     SWAP ;
                     CDR ;
                     SWAP ;
                     PAIR ;
                     DIP { DROP 3 } } ;
                 DUP ;
                 CAR ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 CDR ;
                 DUP ;
                 CDR ;
                 CAR ;
                 CAR ;
                 SENDER ;
                 GET ;
                 IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 CAR ;
                 CDR ;
                 CAR ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 COMPARE ;
                 GT ;
                 IF { PUSH string "Maximum number of proposal reached" ; FAILWITH }
                    { PUSH unit Unit } ;
                 NIL operation ;
                 DIG 3 ;
                 DUP ;
                 DUG 4 ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 PAIR ;
                 DIG 4 ;
                 DUP ;
                 DUG 5 ;
                 CDR ;
                 CDR ;
                 DIG 6 ;
                 DUP ;
                 DUG 7 ;
                 SIZE ;
                 COMPARE ;
                 GE ;
                 IF { DIG 4 ;
                      DUP ;
                      DUG 5 ;
                      DIG 5 ;
                      DUP ;
                      DUG 6 ;
                      CAR ;
                      CDR ;
                      CDR ;
                      DIG 12 ;
                      DUP ;
                      DUG 13 ;
                      NONE (set address) ;
                      SWAP ;
                      UPDATE ;
                      DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
                      SWAP ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      PAIR ;
                      DUP ;
                      CDR ;
                      CAR ;
                      CDR ;
                      DIG 13 ;
                      DUP ;
                      DUG 14 ;
                      SWAP ;
                      EXEC ;
                      DIG 1 ;
                      DUP ;
                      DUG 2 ;
                      DIG 13 ;
                      DUP ;
                      DUG 14 ;
                      DIG 3 ;
                      DUP ;
                      DUG 4 ;
                      CDR ;
                      CAR ;
                      CDR ;
                      CONCAT ;
                      SHA256 ;
                      DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CAR } ;
                      SWAP ;
                      PAIR ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      DUP ;
                      DIG 1 ;
                      DUP ;
                      DUG 2 ;
                      CDR ;
                      CAR ;
                      CAR ;
                      ITER { SWAP ;
                             PAIR ;
                             DUP ;
                             CAR ;
                             DIG 1 ;
                             DUP ;
                             DUG 2 ;
                             CDR ;
                             CAR ;
                             DIG 11 ;
                             DUP ;
                             DUG 12 ;
                             DIG 1 ;
                             DUP ;
                             DUG 2 ;
                             MEM ;
                             IF { DIG 1 ;
                                  DUP ;
                                  DUG 2 ;
                                  DIG 2 ;
                                  DUP ;
                                  DUG 3 ;
                                  CDR ;
                                  CAR ;
                                  CAR ;
                                  PUSH nat 1 ;
                                  DIG 5 ;
                                  DUP ;
                                  DUG 6 ;
                                  CDR ;
                                  CDR ;
                                  SUB ;
                                  ABS ;
                                  DIG 3 ;
                                  DUP ;
                                  DUG 4 ;
                                  SWAP ;
                                  SOME ;
                                  SWAP ;
                                  UPDATE ;
                                  DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ;
                                  PAIR ;
                                  PAIR ;
                                  SWAP ;
                                  PAIR ;
                                  DIG 2 ;
                                  DUP ;
                                  DUG 3 ;
                                  DIG 1 ;
                                  DUP ;
                                  DUG 2 ;
                                  DIP { DROP 2 } }
                                { DIG 1 ; DUP ; DUG 2 } ;
                             DIG 3 ;
                             DUP ;
                             DUG 4 ;
                             DIG 1 ;
                             DUP ;
                             DUG 2 ;
                             SWAP ;
                             CDR ;
                             SWAP ;
                             PAIR ;
                             CAR ;
                             DIP { DROP 4 } } ;
                      DIG 4 ;
                      DUP ;
                      DUG 5 ;
                      DIG 4 ;
                      DUP ;
                      DUG 5 ;
                      SWAP ;
                      CAR ;
                      PAIR ;
                      DIG 3 ;
                      DUP ;
                      DUG 4 ;
                      SWAP ;
                      CDR ;
                      SWAP ;
                      PAIR ;
                      DIG 2 ;
                      DUP ;
                      DUG 3 ;
                      SWAP ;
                      CAR ;
                      PAIR ;
                      DIG 1 ;
                      DUP ;
                      DUG 2 ;
                      SWAP ;
                      CAR ;
                      PAIR ;
                      DIP { DROP 4 } }
                    { DUP ;
                      DIG 5 ;
                      DUP ;
                      DUG 6 ;
                      DIG 6 ;
                      DUP ;
                      DUG 7 ;
                      CAR ;
                      CDR ;
                      CDR ;
                      DIG 8 ;
                      DUP ;
                      DUG 9 ;
                      DIG 14 ;
                      DUP ;
                      DUG 15 ;
                      SWAP ;
                      SOME ;
                      SWAP ;
                      UPDATE ;
                      DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
                      SWAP ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      PAIR ;
                      SWAP ;
                      CAR ;
                      PAIR } ;
                 DUP ;
                 DIP { DROP 17 } } ;
             DIP { DROP } }
           { DIG 1 ;
             DUP ;
             DUG 2 ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             PAIR ;
             DUP ;
             CDR ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             CAR ;
             PACK ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             CAR ;
             CDR ;
             CDR ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             GET ;
             IF_NONE
               { DIG 1 ; DUP ; DUG 2 }
               { DUP ;
                 PUSH bool False ;
                 SENDER ;
                 UPDATE ;
                 DUP ;
                 SIZE ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 SIZE ;
                 COMPARE ;
                 NEQ ;
                 IF { DIG 3 ;
                      DUP ;
                      DUG 4 ;
                      DIG 4 ;
                      DUP ;
                      DUG 5 ;
                      CDR ;
                      CAR ;
                      CAR ;
                      PUSH nat 1 ;
                      DIG 6 ;
                      DUP ;
                      DUG 7 ;
                      CDR ;
                      CAR ;
                      CAR ;
                      SENDER ;
                      GET ;
                      IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
                      SUB ;
                      ABS ;
                      SOME ;
                      SENDER ;
                      UPDATE ;
                      DIP { DUP ; CAR ; SWAP ; CDR ; DUP ; CDR ; SWAP ; CAR ; CDR } ;
                      PAIR ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      DIG 4 ;
                      DUP ;
                      DUG 5 ;
                      DIG 1 ;
                      DUP ;
                      DUG 2 ;
                      DIP { DROP 2 } }
                    { DIG 3 ; DUP ; DUG 4 } ;
                 PUSH nat 0 ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 SIZE ;
                 COMPARE ;
                 EQ ;
                 IF { DUP ;
                      DIG 1 ;
                      DUP ;
                      DUG 2 ;
                      CAR ;
                      CDR ;
                      CDR ;
                      DIG 5 ;
                      DUP ;
                      DUG 6 ;
                      NONE (set address) ;
                      SWAP ;
                      UPDATE ;
                      DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
                      SWAP ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      PAIR ;
                      DIG 1 ;
                      DUP ;
                      DUG 2 ;
                      DIG 1 ;
                      DUP ;
                      DUG 2 ;
                      DIP { DROP 2 } }
                    { DUP ;
                      DIG 1 ;
                      DUP ;
                      DUG 2 ;
                      DIG 2 ;
                      DUP ;
                      DUG 3 ;
                      CAR ;
                      CDR ;
                      CDR ;
                      DIG 4 ;
                      DUP ;
                      DUG 5 ;
                      DIG 7 ;
                      DUP ;
                      DUG 8 ;
                      SWAP ;
                      SOME ;
                      SWAP ;
                      UPDATE ;
                      DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CAR ; SWAP ; CDR ; CAR } ;
                      SWAP ;
                      PAIR ;
                      SWAP ;
                      PAIR ;
                      PAIR ;
                      DIP { DROP } } ;
                 DIG 5 ;
                 DUP ;
                 DUG 6 ;
                 DIG 2 ;
                 DUP ;
                 DUG 3 ;
                 DIP { DROP } ;
                 DIG 1 ;
                 DUP ;
                 DUG 2 ;
                 DIP { DROP 5 } } ;
             DUP ;
             NIL operation ;
             PAIR ;
             DIP { DROP 5 } } ;
         DIP { DROP 2 } } } |} ]

let%expect_test _ =
  run_ligo_good [ "compile-contract" ; contract "vote.mligo" ; "main" ] ;
  [%expect {|
{ parameter
    (or (pair %reset (pair (timestamp %finish_time) (timestamp %start_time)) (string %title))
        (or %vote (unit %nay) (unit %yea))) ;
  storage
    (pair (pair (pair (timestamp %finish_time) (nat %nay))
                (pair (timestamp %start_time) (string %title)))
          (pair (set %voters address) (nat %yea))) ;
  code { DUP ;
         CAR ;
         IF_LEFT
           { PUSH nat 0 ;
             EMPTY_SET address ;
             PAIR ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             CDR ;
             DIG 2 ;
             DUP ;
             DUG 3 ;
             CAR ;
             CDR ;
             PAIR ;
             PUSH nat 0 ;
             DIG 3 ;
             DUP ;
             DUG 4 ;
             CAR ;
             CAR ;
             PAIR ;
             PAIR ;
             PAIR ;
             NIL operation ;
             PAIR ;
             DIP { DROP } }
           { DIG 1 ;
             DUP ;
             DUG 2 ;
             CDR ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             PAIR ;
             DUP ;
             CDR ;
             NOW ;
             SENDER ;
             DIG 3 ;
             DUP ;
             DUG 4 ;
             CAR ;
             IF_LEFT
               { DIG 3 ;
                 DUP ;
                 DUG 4 ;
                 PUSH nat 1 ;
                 DIG 5 ;
                 DUP ;
                 DUG 6 ;
                 CAR ;
                 CAR ;
                 CDR ;
                 ADD ;
                 DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CDR ; SWAP ; CAR ; CAR } ;
                 SWAP ;
                 PAIR ;
                 PAIR ;
                 PAIR ;
                 DIP { DROP } }
               { DIG 3 ;
                 DUP ;
                 DUG 4 ;
                 PUSH nat 1 ;
                 DIG 5 ;
                 DUP ;
                 DUG 6 ;
                 CDR ;
                 CDR ;
                 ADD ;
                 DIP { DUP ; CAR ; SWAP ; CDR ; CAR } ;
                 SWAP ;
                 PAIR ;
                 SWAP ;
                 PAIR ;
                 DIP { DROP } } ;
             DUP ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             CDR ;
             CAR ;
             DIG 3 ;
             DUP ;
             DUG 4 ;
             PUSH bool True ;
             SWAP ;
             UPDATE ;
             DIP { DUP ; CAR ; SWAP ; CDR ; CDR } ;
             PAIR ;
             SWAP ;
             PAIR ;
             NIL operation ;
             PAIR ;
             DIP { DROP 6 } } ;
         DIP { DROP } } } |}]

let%expect_test _ =
    run_ligo_good [ "compile-contract" ; contract "implicit.mligo" ; "main" ] ;
    [%expect {|
      { parameter key_hash ;
        storage unit ;
        code { DUP ;
               CAR ;
               IMPLICIT_ACCOUNT ;
               UNIT ;
               NIL operation ;
               PAIR ;
               DIP { DROP 2 } } } |}]

let%expect_test _ =
  run_ligo_good [ "compile-contract" ; contract "amount_lambda.mligo" ; "main" ] ;
  (* AMOUNT should occur inside the second lambda, but not the first lambda *)
  [%expect {|
    { parameter bool ;
      storage (lambda unit mutez) ;
      code { DUP ;
             CAR ;
             IF { AMOUNT ;
                  DUP ;
                  LAMBDA
                    (pair mutez unit)
                    mutez
                    { DUP ; CAR ; SWAP ; CDR ; DIG 1 ; DUP ; DUG 2 ; DIP { DROP 2 } } ;
                  SWAP ;
                  APPLY ;
                  DIP { DROP } }
                { LAMBDA unit mutez { DROP ; AMOUNT } } ;
             NIL operation ;
             PAIR ;
             DIP { DROP } } } |}]

let%expect_test _ =
  run_ligo_good [ "print-ast-typed" ; contract "sequence.mligo" ; ];
  [%expect {| const y = lambda (_) return let x = +1 in let _ = let x = +2 in UNIT() in let _ = let x = +23 in UNIT() in let _ = let x = +42 in UNIT() in x |}]

let%expect_test _ =
  run_ligo_bad [ "compile-contract" ; contract "bad_type_operator.ligo" ; "main" ] ;
  [%expect {|
    ligo: error
    in file "bad_type_operator.ligo", line 4, characters 16-29
    unrecognized type operator (type_operator: Map (binding))


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}]

let%expect_test _ =
  run_ligo_bad [ "compile-contract" ; contract "bad_address_format.religo" ; "main" ] ;
  [%expect {|
    ligo: error
    in file "bad_address_format.religo", line 2, characters 26-48
    Badly formatted literal: @"KT1badaddr"


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}]

let%expect_test _ =
  run_ligo_bad [ "compile-contract" ; contract "bad_timestamp.ligo" ; "main" ] ;
  [%expect {|
    ligo: error
    in file "bad_timestamp.ligo", line 7, characters 30-44
    Badly formatted timestamp 'badtimestamp'


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}]

let%expect_test _ =
    run_ligo_good [ "dry-run" ; contract "redeclaration.ligo" ; "main" ; "unit" ; "0" ] ;
    [%expect {|( LIST_EMPTY() , 0 ) |}]

let%expect_test _ =
    run_ligo_good [ "dry-run" ; contract "double_main.ligo" ; "main" ; "unit" ; "0" ] ;
    [%expect {|( LIST_EMPTY() , 2 ) |}]

let%expect_test _ =
  run_ligo_good [ "compile-contract" ; contract "subtle_nontail_fail.mligo" ; "main" ] ;
  [%expect {|
    { parameter unit ;
      storage unit ;
      code { PUSH bool True ;
             IF { PUSH string "This contract always fails" ; FAILWITH }
                { PUSH string "This contract still always fails" ; FAILWITH } } } |}]

let%expect_test _ =
  (* TODO should not be bad? *)
  run_ligo_good [ "dry-run" ; contract "subtle_nontail_fail.mligo" ; "main" ; "()" ; "()" ] ;
  [%expect {|
    failwith("This contract always fails") |}]

let%expect_test _ =
  run_ligo_bad [ "compile-contract" ; bad_contract "self_in_lambda.mligo" ; "main" ] ;
  [%expect {|
    ligo: error
    SELF_ADDRESS is only allowed at top-level


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}]

let%expect_test _ =
  run_ligo_good [ "compile-storage" ; contract "big_map.ligo" ; "main" ; "(big_map1,unit)" ] ;
  [%expect {|
    (Pair { Elt 23 0 ; Elt 42 0 } Unit) |}]

let%expect_test _ =
  run_ligo_good [ "compile-contract" ; contract "key_hash_comparable.ligo" ; "main" ] ;
  [%expect {|
    { parameter int ;
      storage (pair (map %one key_hash nat) (big_map %two key_hash bool)) ;
      code { DUP ; CDR ; NIL operation ; PAIR ; DIP { DROP } } } |}]

let%expect_test _ =
  run_ligo_bad [ "compile-contract" ; bad_contract "long_sum_type_names.ligo" ; "main" ] ;
  [%expect {|
    ligo: error
    in file "long_sum_type_names.ligo", line 2, character 2 to line 4, character 18
    Too long constructor 'Incrementttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttttt'
    names length are limited to 32 (tezos limitation)


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}]

let%expect_test _ =
  run_ligo_good [ "dry-run" ; contract "super-counter.mligo" ; "main" ; "test_param" ; "test_storage" ] ;
  [%expect {|
    ( LIST_EMPTY() , 3 ) |}]

let%expect_test _ =
  run_ligo_bad [ "compile-contract" ; bad_contract "redundant_constructors.mligo" ; "main" ] ;
  [%expect {|
    ligo: error
    in file "redundant_constructors.mligo", line 7, character 2 to line 9, character 15
    Redundant constructor:
    Add
    - Env:[]	Type env:[union_a -> sum[Add -> int , Remove -> int]
    bool -> sum[false -> unit , true -> unit]]


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}]

let%expect_test _ =
  run_ligo_bad [ "compile-contract" ; bad_contract "create_contract_toplevel.mligo" ; "main" ] ;
  [%expect {|
ligo: error
in file "create_contract_toplevel.mligo", line 3, characters 0-3
Constant declaration 'main'
in file "create_contract_toplevel.mligo", line 4, character 35 to line 8, character 8
Free variable 'store' is not allowed in CREATE_CONTRACT lambda


If you're not sure how to fix this error, you can do one of the following:

* Visit our documentation: https://ligolang.org/docs/intro/introduction
* Ask a question on our Discord: https://discord.gg/9rhYaEt
* Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
* Check the changelog by running 'ligo changelog' |}] ;

  run_ligo_bad [ "compile-contract" ; bad_contract "create_contract_var.mligo" ; "main" ] ;
  [%expect {|
ligo: error
in file "create_contract_var.mligo", line 5, characters 0-3
Constant declaration 'main'
in file "create_contract_var.mligo", line 6, character 35 to line 10, character 5
Free variable 'a' is not allowed in CREATE_CONTRACT lambda


If you're not sure how to fix this error, you can do one of the following:

* Visit our documentation: https://ligolang.org/docs/intro/introduction
* Ask a question on our Discord: https://discord.gg/9rhYaEt
* Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
* Check the changelog by running 'ligo changelog' |}] ;

  run_ligo_bad [ "compile-contract" ; bad_contract "create_contract_no_inline.mligo" ; "main" ] ;
  [%expect {|
    ligo: error
    in file "create_contract_no_inline.mligo", line 3, characters 40-46
    Unbound type variable 'return'
    - Env:[foo -> int]	Type env:[bool -> sum[false -> unit , true -> unit]]


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}] ;

  run_ligo_good [ "compile-contract" ; contract "create_contract.mligo" ; "main" ] ;
  [%expect {|
    { parameter string ;
      storage string ;
      code { PUSH string "un" ;
             PUSH mutez 300000000 ;
             NONE key_hash ;
             CREATE_CONTRACT
               { parameter nat ;
                 storage string ;
                 code { PUSH string "one" ; NIL operation ; PAIR ; DIP { DROP } } } ;
             PAIR ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             CDR ;
             NIL operation ;
             DIG 2 ;
             DUP ;
             DUG 3 ;
             CAR ;
             CONS ;
             PAIR ;
             DIP { DROP 2 } } } |}];

  run_ligo_good [ "compile-contract" ; contract "tuples_no_annotation.religo" ; "main" ] ;
  [%expect {|
    { parameter int ;        
      storage (pair (pair int string) (pair nat bool)) ;
      code { PUSH bool False ;
             PUSH nat 2 ;
             PAIR ;
             PUSH string "2" ;
             PUSH int 2 ;
             PAIR ;
             PAIR ;
             NIL operation ;
             PAIR ;
             DIP { DROP } } } |}]

let%expect_test _ =
  run_ligo_bad [ "compile-contract" ; bad_contract "self_type_annotation.ligo" ; "main" ] ;
  [%expect {|
    ligo: error
    in file "self_type_annotation.ligo", line 8, characters 41-64
    Bad self type
    expected (type_operator: Contract (int))
    got (type_operator: Contract (nat))


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}] ;

  run_ligo_good [ "compile-contract" ; contract "self_type_annotation.ligo" ; "main" ] ;
  [%expect {|
    { parameter nat ;
      storage int ;
      code { SELF %default ;
             DIG 1 ;
             DUP ;
             DUG 2 ;
             CDR ;
             NIL operation ;
             PAIR ;
             DIP { DROP 2 } } } |}]

let%expect_test _ =
  run_ligo_bad [ "compile-contract" ; bad_contract "bad_contract.mligo" ; "main" ] ;
  [%expect {|
    ligo: error
    in file "bad_contract.mligo", line 4, characters 0-3
    Badly typed contract:
    unexpected entrypoint type ( nat * int ) -> int


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}] ;

  run_ligo_bad [ "compile-contract" ; bad_contract "bad_contract2.mligo" ; "main" ] ;
  [%expect {|
    ligo: error
    in file "bad_contract2.mligo", line 5, characters 0-3
    Badly typed contract:
    expected (type_operator: list(operation)) but got string


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}] ;

  run_ligo_bad [ "compile-contract" ; bad_contract "bad_contract3.mligo" ; "main" ] ;
  [%expect {|
    ligo: error
    in file "bad_contract3.mligo", line 5, characters 0-3
    Badly typed contract main:
    expected storage type as right member of a pair in the input and output, but got:
    - int in the input
    - string in the output


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}]

let%expect_test _ =
  run_ligo_good [ "compile-contract" ; contract "self_with_entrypoint.ligo" ; "main" ] ;
  [%expect {|
    { parameter (or (unit %default) (int %toto)) ;
      storage nat ;
      code { SELF %toto ;
             DUP ;
             PUSH mutez 300000000 ;
             PUSH int 2 ;
             TRANSFER_TOKENS ;
             DIG 2 ;
             DUP ;
             DUG 3 ;
             CDR ;
             NIL operation ;
             DIG 2 ;
             DUP ;
             DUG 3 ;
             CONS ;
             PAIR ;
             DIP { DROP 3 } } } |}] ;

  run_ligo_good [ "compile-contract" ; contract "self_without_entrypoint.ligo" ; "main" ] ;
  [%expect {|
    { parameter int ;
      storage nat ;
      code { SELF %default ;
             DUP ;
             PUSH mutez 300000000 ;
             PUSH int 2 ;
             TRANSFER_TOKENS ;
             DIG 2 ;
             DUP ;
             DUG 3 ;
             CDR ;
             NIL operation ;
             DIG 2 ;
             DUP ;
             DUG 3 ;
             CONS ;
             PAIR ;
             DIP { DROP 3 } } } |}] ;

  run_ligo_bad [ "compile-contract" ; bad_contract "self_bad_entrypoint_format.ligo" ; "main" ] ;
  [%expect {|
    ligo: error
    in file "self_bad_entrypoint_format.ligo", line 8, characters 52-58
    Bad entrypoint format 'Toto'
    We expect '%bar' for entrypoint Bar and '%default' when no entrypoint used


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}];

  run_ligo_bad ["compile-contract"; bad_contract "nested_bigmap_1.religo"; "main"];
  [%expect {|
    ligo: error
    in file "nested_bigmap_1.religo", line 1, characters 11-29
    It looks like you have nested a big map inside another big map, this is not supported


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}];

  run_ligo_bad ["compile-contract"; bad_contract "nested_bigmap_2.religo"; "main"];
  [%expect {|
    ligo: error
    in file "nested_bigmap_2.religo", line 2, characters 29-50
    It looks like you have nested a big map inside another big map, this is not supported


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}];
  
  run_ligo_bad ["compile-contract"; bad_contract "nested_bigmap_3.religo"; "main"];
  [%expect {|
    ligo: error
    in file "nested_bigmap_3.religo", line 1, characters 11-29
    It looks like you have nested a big map inside another big map, this is not supported


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}];

  run_ligo_bad ["compile-contract"; bad_contract "nested_bigmap_4.religo"; "main"];
  [%expect {|
    ligo: error
    in file "nested_bigmap_4.religo", line 2, characters 39-60
    It looks like you have nested a big map inside another big map, this is not supported


    If you're not sure how to fix this error, you can do one of the following:

    * Visit our documentation: https://ligolang.org/docs/intro/introduction
    * Ask a question on our Discord: https://discord.gg/9rhYaEt
    * Open a gitlab issue: https://gitlab.com/ligolang/ligo/issues/new
    * Check the changelog by running 'ligo changelog' |}];
      
  run_ligo_good ["print-ast"; contract "letin.mligo"];
  [%expect {|
    type storage = (int ,
    int)
    const main : (int ,
    storage) -> ((TO_list(operation)) ,
    storage) = lambda (n:Some((int ,
    storage))) : None return let x = let x = 7 : int in (ADD(x ,
    n.0) ,
    ADD(n.1.0 ,
    n.1.1)) : (int ,
    int) in (list[] : (TO_list(operation)) ,
    x)
    const f0 = lambda (a:Some(string)) : None return true(unit)
    const f1 = lambda (a:Some(string)) : None return true(unit)
    const f2 = lambda (a:Some(string)) : None return true(unit)
    const letin_nesting = lambda (_:Some(unit)) : None return let s = "test" in let p0 = (f0)@(s) in { ASSERTION(p0);
     let p1 = (f1)@(s) in { ASSERTION(p1);
     let p2 = (f2)@(s) in { ASSERTION(p2);
     s}}}
    const letin_nesting2 = lambda (x:Some(int)) : None return let y = 2 in let z = 3 in ADD(ADD(x ,
    y) ,
    z)
    |}];

  run_ligo_good ["print-ast"; contract "letin.religo"];
  [%expect {|
    type storage = (int ,
    int)
    const main : (int ,
    storage) -> ((TO_list(operation)) ,
    storage) = lambda (n:Some((int ,
    storage))) : None return let x = let x = 7 : int in (ADD(x ,
    n.0) ,
    ADD(n.1.0 ,
    n.1.1)) : (int ,
    int) in (list[] : (TO_list(operation)) ,
    x)
    const f0 = lambda (a:Some(string)) : None return true(unit)
    const f1 = lambda (a:Some(string)) : None return true(unit)
    const f2 = lambda (a:Some(string)) : None return true(unit)
    const letin_nesting = lambda (_:Some(unit)) : None return let s = "test" in let p0 = (f0)@(s) in { ASSERTION(p0);
     let p1 = (f1)@(s) in { ASSERTION(p1);
     let p2 = (f2)@(s) in { ASSERTION(p2);
     s}}}
    const letin_nesting2 = lambda (x:Some(int)) : None return let y = 2 in let z = 3 in ADD(ADD(x ,
    y) ,
    z)
    |}];