path: root/lux-jvm/test/test/luxc/lang/translation/jvm.lux

(.module:
  lux
  (lux [io]
       (control pipe
                [monad {"+" [do]}]
                [maybe])
       (data ["e" error]
             [bit]
             [bit "bit/" Eq<Bit>]
             [number "int/" Number<Int> Codec<Text,Int>]
             [text "text/" Eq<Text>]
             text/format
             (coll [list]))
       ["r" math/random "r/" Monad<Random>]
       [macro]
       (macro [code])
       [host]
       test)
  (luxc [lang]
        (lang ["[0]L" host]
              ["ls" synthesis]
              (translation (jvm ["[0]T" expression]
                                ["[0]T" eval]
                                ["[0]T" runtime]))))
  (test/luxc common))

(context: "Conversions [Part 1]"
  (<| (times +100)
      (do @
        [int-sample (|> r.int (:: @ each (i/% 128)))
         #let [frac-sample (int-to-frac int-sample)]]
        (with-expansions [<2step> (template [<step1> <step2> <tag> <sample> <cast> <test>]
                                    [(test (format <step1> " / " <step2>)
                                           (|> (do macro.Monad<Meta>
                                                 [sampleI (expressionT.translate (|> (~ (<tag> <sample>)) <step1> <step2> (`)))]
                                                 (evalT.eval sampleI))
                                               (lang.with-current-module "")
                                               (macro.result (io.run! init-jvm))
                                               (case> {#e.Success valueT}
                                                      (<test> <sample> (:coerce <cast> valueT))

                                                      {#e.Error error}
                                                      #0)))]

                                    ["jvm convert double-to-float" "jvm convert float-to-double" code.frac frac-sample Frac f/=]
                                    ["jvm convert double-to-int"   "jvm convert int-to-double" code.frac frac-sample Frac f/=]
                                    ["jvm convert double-to-long"  "jvm convert long-to-double" code.frac frac-sample Frac f/=]

                                    ["jvm convert long-to-float" "jvm convert float-to-long" code.int int-sample Int i/=]
                                    ["jvm convert long-to-int" "jvm convert int-to-long" code.int int-sample Int i/=]
                                    ["jvm convert long-to-short" "jvm convert short-to-long" code.int int-sample Int i/=]
                                    ["jvm convert long-to-byte" "jvm convert byte-to-long" code.int int-sample Int i/=]
                                    )]
                         ($_ seq
                             <2step>
                             )))))

(context: "Conversions [Part 2]"
  (<| (times +100)
      (do @
        [int-sample (|> r.int (:: @ each (|>> (i/% 128) int/abs)))
         #let [frac-sample (int-to-frac int-sample)]]
        (`` ($_ seq
                (~~ (template [<step1> <step2> <step3> <tag> <sample> <cast> <test>]
                      [(test (format <step1> " / " <step2> " / " <step3>)
                             (|> (do macro.Monad<Meta>
                                   [sampleI (expressionT.translate (|> (~ (<tag> <sample>)) <step1> <step2> <step3> (`)))]
                                   (evalT.eval sampleI))
                                 (lang.with-current-module "")
                                 (macro.result (io.run! init-jvm))
                                 (case> {#e.Success valueT}
                                        (<test> <sample> (:coerce <cast> valueT))

                                        {#e.Error error}
                                        #0)))]

                      ["jvm convert long-to-int"   "jvm convert int-to-char"  "jvm convert char-to-long"  code.int int-sample Int i/=]
                      ["jvm convert long-to-int"   "jvm convert int-to-byte"  "jvm convert byte-to-long"  code.int int-sample Int i/=]
                      ["jvm convert long-to-int"   "jvm convert int-to-short" "jvm convert short-to-long" code.int int-sample Int i/=]
                      ["jvm convert long-to-float" "jvm convert float-to-int" "jvm convert int-to-long"   code.int int-sample Int i/=]
                      ["jvm convert long-to-int"   "jvm convert int-to-float" "jvm convert float-to-long" code.int int-sample Int i/=]
                      ))
                )))))

(context: "Conversions [Part 3]"
  (<| (times +100)
      (do @
        [int-sample (|> r.int (:: @ each (|>> (i/% 128) int/abs)))
         #let [frac-sample (int-to-frac int-sample)]]
        (`` ($_ seq
                (~~ (template [<step1> <step2> <step3> <step4> <tag> <sample> <cast> <test>]
                      [(test (format <step1> " / " <step2> " / " <step3>)
                             (|> (do macro.Monad<Meta>
                                   [sampleI (expressionT.translate (|> (~ (<tag> <sample>)) <step1> <step2> <step3> <step4> (`)))]
                                   (evalT.eval sampleI))
                                 (lang.with-current-module "")
                                 (macro.result (io.run! init-jvm))
                                 (case> {#e.Success valueT}
                                        (<test> <sample> (:coerce <cast> valueT))

                                        {#e.Error error}
                                        #0)))]

                      ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-byte" "jvm convert byte-to-long" code.int int-sample Int i/=]
                      ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-short" "jvm convert short-to-long" code.int int-sample Int i/=]
                      ["jvm convert long-to-int" "jvm convert int-to-char" "jvm convert char-to-int" "jvm convert int-to-long" code.int int-sample Int i/=]
                      ))
                )))))

(def: gen-nat
  (r.Random Nat)
  (|> r.nat
      (r/each (n/% +128))
      (r.filter (|>> (n/= +0) not))))

(def: gen-int
  (r.Random Int)
  (|> gen-nat (r/each nat-to-int)))

(def: gen-frac
  (r.Random Frac)
  (|> gen-int (r/each int-to-frac)))

(template [<domain> <generator> <tag> <type> <test> <augmentation> <+> <-> <*> </> <%> <pre> <post>]
  [(context: (format "Arithmetic [" <domain> "]")
     (<| (times +100)
         (do @
           [param <generator>
            #let [subject (<augmentation> param)]]
           (with-expansions [<tests> (template [<procedure> <reference>]
                                       [(test <procedure>
                                              (|> (do macro.Monad<Meta>
                                                    [sampleI (expressionT.translate (<post> ((code.text <procedure>)
                                                                                             (<pre> (<tag> subject))
                                                                                             (<pre> (<tag> param)))))]
                                                    (evalT.eval sampleI))
                                                  (lang.with-current-module "")
                                                  (macro.result (io.run! init-jvm))
                                                  (case> {#e.Success valueT}
                                                         (<test> (<reference> param subject)
                                                                 (:coerce <type> valueT))

                                                         {#e.Error error}
                                                         #0)))]

                                       [(format "jvm " <domain> " +") <+>]
                                       [(format "jvm " <domain> " -") <->]
                                       [(format "jvm " <domain> " *") <*>]
                                       [(format "jvm " <domain> " /") </>]
                                       [(format "jvm " <domain> " %") <%>]
                                       )]
                            ($_ seq
                                <tests>
                                )))))]

  ["int" gen-int code.int Int i/= (i/* 10) i/+ i/- i/* i// i/% "jvm convert long-to-int" "jvm convert int-to-long"]
  ["long" gen-int code.int Int i/= (i/* 10) i/+ i/- i/* i// i/% id id]
  ["float" gen-frac code.frac Frac f/= (f/* 10.0) f/+ f/- f/* f// f/% "jvm convert double-to-float" "jvm convert float-to-double"]
  ["double" gen-frac code.frac Frac f/= (f/* 10.0) f/+ f/- f/* f// f/% id id]
  )

(template [<domain> <post> <convert>]
  [(context: (format "Bit-wise [" <domain> "] { Combiners ]")
     (<| (times +100)
         (do @
           [param gen-nat
            subject gen-nat]
           (`` ($_ seq
                   (~~ (template [<procedure> <reference>]
                         [(test <procedure>
                                (|> (do macro.Monad<Meta>
                                      [sampleI (expressionT.translate (<post> ((code.text <procedure>)
                                                                               (<convert> (code.nat subject))
                                                                               (<convert> (code.nat param)))))]
                                      (evalT.eval sampleI))
                                    (lang.with-current-module "")
                                    (macro.result (io.run! init-jvm))
                                    (case> {#e.Success valueT}
                                           (n/= (<reference> param subject)
                                                (:coerce Nat valueT))

                                           {#e.Error error}
                                           #0)))]

                         [(format "jvm " <domain> " and") bit.and]
                         [(format "jvm " <domain> " or") bit.or]
                         [(format "jvm " <domain> " xor") bit.xor]
                         ))
                   )))))]

  ["int" "jvm convert int-to-long" "jvm convert long-to-int"]
  ["long" id id]
  )

(template [<domain> <post> <convert>]
  [(context: (format "Bit-wise [" <domain> "] { Shifters }")
     (<| (times +100)
         (do @
           [param gen-nat
            subject gen-nat
            #let [shift (n/% +10 param)]]
           (`` ($_ seq
                   (~~ (template [<procedure> <reference> <type> <test> <pre-subject> <pre>]
                         [(test <procedure>
                                (|> (do macro.Monad<Meta>
                                      [sampleI (expressionT.translate (<post> ((code.text <procedure>)
                                                                               (<convert> (<pre> subject))
                                                                               ("jvm convert long-to-int" (code.nat shift)))))]
                                      (evalT.eval sampleI))
                                    (lang.with-current-module "")
                                    (macro.result (io.run! init-jvm))
                                    (case> {#e.Success valueT}
                                           (<test> (<reference> shift (<pre-subject> subject))
                                                   (:coerce <type> valueT))

                                           {#e.Error error}
                                           #0)))]

                         [(format "jvm " <domain> " shl") bit.left-shift Nat n/= id code.nat]
                         [(format "jvm " <domain> " shr") bit.arithmetic-right-shift Int i/= nat-to-int (|>> nat-to-int code.int)]
                         [(format "jvm " <domain> " ushr") bit.logical-right-shift Nat n/= id code.nat]
                         ))
                   )))))]

  ["int" "jvm convert int-to-long" "jvm convert long-to-int"]
  ["long" id id]
  )

(template [<domain> <generator> <tag> <=> <<> <pre>]
  [(context: (format "Order [" <domain> "]")
     (<| (times +100)
         (do @
           [param <generator>
            subject <generator>]
           (with-expansions [<tests> (template [<procedure> <reference>]
                                       [(test <procedure>
                                              (|> (do macro.Monad<Meta>
                                                    [sampleI (expressionT.translate ((code.text <procedure>)
                                                                                     (<pre> (<tag> subject))
                                                                                     (<pre> (<tag> param))))]
                                                    (evalT.eval sampleI))
                                                  (lang.with-current-module "")
                                                  (macro.result (io.run! init-jvm))
                                                  (case> {#e.Success valueT}
                                                         (bit/= (<reference> param subject)
                                                                (:coerce Bit valueT))

                                                         {#e.Error error}
                                                         #0)))]

                                       [(format "jvm " <domain> " =") <=>]
                                       [(format "jvm " <domain> " <") <<>]
                                       )]
                            ($_ seq
                                <tests>
                                )))))]

  ["int" gen-int code.int i/= i/< "jvm convert long-to-int"]
  ["long" gen-int code.int i/= i/< id]
  ["float" gen-frac code.frac f/= f/< "jvm convert double-to-float"]
  ["double" gen-frac code.frac f/= f/< id]
  ["char" gen-int code.int i/= i/< "jvm convert long-to-char"]
  )

(def: (jvm//array//new dimension class size)
  (-> Nat Text Nat ls.Synthesis)
  (` ("jvm array new" (~ (code.nat dimension)) (~ (code.text class)) (~ (code.nat size)))))

(def: (jvm//array//write class idx inputS arrayS)
  (-> Text Nat ls.Synthesis ls.Synthesis ls.Synthesis)
  (` ("jvm array write" (~ (code.text class)) (~ (code.nat idx)) (~ inputS) (~ arrayS))))

(def: (jvm//array//read class idx arrayS)
  (-> Text Nat ls.Synthesis ls.Synthesis)
  (` ("jvm array read" (~ (code.text class)) (~ (code.nat idx)) (~ arrayS))))

(context: "Array [Part 1]"
  (<| (times +100)
      (do @
        [size (|> r.nat (:: @ each (|>> (n/% +10) (n/max +1))))
         idx (|> r.nat (:: @ each (n/% size)))
         valueZ r.bit
         valueB gen-int
         valueS gen-int
         valueI gen-int
         valueL r.int
         valueF gen-frac
         valueD r.frac
         valueC gen-int]
        (with-expansions [<array> (template [<class> <type> <value> <test> <input> <post>]
                                    [(test <class>
                                           (|> (do macro.Monad<Meta>
                                                 [sampleI (expressionT.translate (|> (jvm//array//new +0 <class> size)
                                                                                     (jvm//array//write <class> idx <input>)
                                                                                     (jvm//array//read <class> idx)
                                                                                     <post>))]
                                                 (evalT.eval sampleI))
                                               (lang.with-current-module "")
                                               (macro.result (io.run! init-jvm))
                                               (case> {#e.Success outputZ}
                                                      (<test> <value> (:coerce <type> outputZ))

                                                      {#e.Error error}
                                                      #0)))]

                                    ["boolean" Bit valueZ bit/= (code.bit valueZ)
                                     id]
                                    ["byte" Int valueB i/= (|> (code.int valueB) (~) "jvm convert long-to-byte" (`))
                                     "jvm convert byte-to-long"]
                                    ["short" Int valueS i/= (|> (code.int valueS) (~) "jvm convert long-to-short" (`))
                                     "jvm convert short-to-long"]
                                    ["int" Int valueI i/= (|> (code.int valueI) (~) "jvm convert long-to-int" (`))
                                     "jvm convert int-to-long"]
                                    ["long" Int valueL i/= (code.int valueL)
                                     id]
                                    ["float" Frac valueF f/= (|> (code.frac valueF) (~) "jvm convert double-to-float" (`))
                                     "jvm convert float-to-double"]
                                    ["double" Frac valueD f/= (code.frac valueD)
                                     id]
                                    )]
                         ($_ seq
                             <array>
                             )))))

(context: "Array [Part 2]"
  (<| (times +100)
      (do @
        [size (|> r.nat (:: @ each (|>> (n/% +10) (n/max +1))))
         idx (|> r.nat (:: @ each (n/% size)))
         valueZ r.bit
         valueB gen-int
         valueS gen-int
         valueI gen-int
         valueL r.int
         valueF gen-frac
         valueD r.frac
         valueC gen-int]
        (with-expansions [<array> (template [<class> <type> <value> <test> <input> <post>]
                                    [(test <class>
                                           (|> (do macro.Monad<Meta>
                                                 [sampleI (expressionT.translate (|> (jvm//array//new +0 <class> size)
                                                                                     (jvm//array//write <class> idx <input>)
                                                                                     (jvm//array//read <class> idx)
                                                                                     <post>))]
                                                 (evalT.eval sampleI))
                                               (lang.with-current-module "")
                                               (macro.result (io.run! init-jvm))
                                               (case> {#e.Success outputT}
                                                      (<test> <value> (:coerce <type> outputT))

                                                      {#e.Error error}
                                                      #0)))]

                                    ["char" Int valueC i/=
                                     (|> (code.int valueC) (~) "jvm convert long-to-int" "jvm convert int-to-char" (`))
                                     "jvm convert char-to-long"]
                                    ["java.lang.Long" Int valueL i/=
                                     (code.int valueL)
                                     id]
                                    )]
                         ($_ seq
                             <array>
                             (test "java.lang.Double (level 1)"
                                   (|> (do macro.Monad<Meta>
                                         [#let [inner (|> ("jvm array new" +0 "java.lang.Double" (~ (code.nat size)))
                                                          ("jvm array write" "java.lang.Double" (~ (code.nat idx)) (~ (code.frac valueD)))
                                                          (`))]
                                          sampleI (expressionT.translate (|> ("jvm array new" +1 "java.lang.Double" (~ (code.nat size)))
                                                                             ("jvm array write" "#Array" (~ (code.nat idx)) (~ inner))
                                                                             ("jvm array read" "#Array" (~ (code.nat idx)))
                                                                             ("jvm array read" "java.lang.Double" (~ (code.nat idx)))
                                                                             (`)))]
                                         (evalT.eval sampleI))
                                       (lang.with-current-module "")
                                       (macro.result (io.run! init-jvm))
                                       (case> {#e.Success outputT}
                                              (f/= valueD (:coerce Frac outputT))

                                              {#e.Error error}
                                              #0)))
                             (test "jvm array length"
                                   (|> (do macro.Monad<Meta>
                                         [sampleI (expressionT.translate (` ("jvm array length" ("jvm array new" +0 "java.lang.Object" (~ (code.nat size))))))]
                                         (evalT.eval sampleI))
                                       (lang.with-current-module "")
                                       (macro.result (io.run! init-jvm))
                                       (case> {#e.Success outputT}
                                              (n/= size (:coerce Nat outputT))

                                              {#e.Error error}
                                              #0)))
                             )))))

(host.import: java/lang/Class
  (getName [] String))

(def: classes
  (List Text)
  (list "java.lang.Object" "java.lang.Class"
        "java.lang.String" "java.lang.Number"))

(def: instances
  (List [Text (r.Random ls.Synthesis)])
  (let [gen-boolean (|> r.bit (:: r.Functor<Random> each code.bit))
        gen-integer (|> r.int (:: r.Functor<Random> each code.int))
        gen-double (|> r.frac (:: r.Functor<Random> each code.frac))
        gen-string (|> (r.text +5) (:: r.Functor<Random> each code.text))]
    (list ["java.lang.Boolean" gen-boolean]
          ["java.lang.Long" gen-integer]
          ["java.lang.Double" gen-double]
          ["java.lang.String" gen-string]
          ["java.lang.Object" (r.either (r.either gen-boolean
                                                  gen-integer)
                                        (r.either gen-double
                                                  gen-string))])))

(context: "Object."
  (<| (times +100)
      (do @
        [#let [num-classes (list.size classes)]
         #let [num-instances (list.size instances)]
         class-idx (|> r.nat (:: @ each (n/% num-classes)))
         instance-idx (|> r.nat (:: @ each (n/% num-instances)))
         exception-message (r.text +5)
         #let [class (maybe.trusted (list.nth class-idx classes))
               [instance-class instance-gen] (maybe.trusted (list.nth instance-idx instances))
               exception-message$ (` ["java.lang.String" (~ (code.text exception-message))])]
         sample r.int
         monitor r.int
         instance instance-gen]
        ($_ seq
            (test "jvm object null"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm object null?" ("jvm object null"))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (:coerce Bit outputT)

                             {#e.Error error}
                             #0)))
            (test "jvm object null?"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm object null?" (~ (code.int sample)))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (not (:coerce Bit outputT))

                             {#e.Error error}
                             #0)))
            (test "jvm object synchronized"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm object synchronized" (~ (code.int monitor)) (~ (code.int sample)))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (i/= sample (:coerce Int outputT))

                             {#e.Error error}
                             #0)))
            (test "jvm object throw"
                  (|> (do macro.Monad<Meta>
                        [_ runtimeT.translate
                         sampleI (expressionT.translate (` ("lux try" ("lux function" +1 []
                                                                       ("jvm object throw" ("jvm member invoke constructor"
                                                                                            "java.lang.Throwable"
                                                                                            (~ exception-message$)))))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (case (:coerce (e.Error Any) outputT)
                               {#e.Error error}
                               (text.contains? exception-message error)

                               {#e.Success outputT}
                               #0)

                             {#e.Error error}
                             #0)))
            (test "jvm object class"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm object class" (~ (code.text class)))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (|> outputT (:coerce Class) (Class::getName []) (text/= class))

                             {#e.Error error}
                             #0)))
            (test "jvm object instance?"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm object instance?" (~ (code.text instance-class)) (~ instance))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (:coerce Bit outputT)

                             {#e.Error error}
                             #0)))
            ))))

(host.import: java/util/GregorianCalendar
  ("static" AD int))

(context: "Member [Field]"
  (<| (times +100)
      (do @
        [sample-short (|> r.int (:: @ each (|>> int/abs (i/% 100))))
         sample-string (r.text +5)
         other-sample-string (r.text +5)
         #let [shortS (` ["short" ("jvm object cast" "java.lang.Short" "short"
                                   ("jvm convert long-to-short" (~ (code.int sample-short))))])
               stringS (` ["java.lang.String" (~ (code.text sample-string))])
               type-codeS (` ["org.omg.CORBA.TypeCode" ("jvm object null")])
               idl-typeS (` ["org.omg.CORBA.IDLType" ("jvm object null")])
               value-memberS (` ("jvm member invoke constructor"
                                 "org.omg.CORBA.ValueMember"
                                 (~ stringS) (~ stringS) (~ stringS) (~ stringS)
                                 (~ type-codeS) (~ idl-typeS) (~ shortS)))]]
        ($_ seq
            (test "jvm member static get"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm convert int-to-long" ("jvm member static get" "java.util.GregorianCalendar" "AD" "int"))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (i/= GregorianCalendar::AD (:coerce Int outputT))

                             {#e.Error error}
                             #0)))
            (test "jvm member static put"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm member static put" "java.awt.datatransfer.DataFlavor" "allHtmlFlavor" "java.awt.datatransfer.DataFlavor"
                                                            ("jvm member static get" "java.awt.datatransfer.DataFlavor" "allHtmlFlavor" "java.awt.datatransfer.DataFlavor"))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (same? hostL.unit (:coerce Text outputT))

                             {#e.Error error}
                             #0)))
            (test "jvm member virtual get"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm member virtual get" "org.omg.CORBA.ValueMember" "name" "java.lang.String" (~ value-memberS))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (text/= sample-string (:coerce Text outputT))

                             {#e.Error error}
                             #0)))
            (test "jvm member virtual put"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm member virtual get" "org.omg.CORBA.ValueMember" "name" "java.lang.String"
                                                            ("jvm member virtual put" "org.omg.CORBA.ValueMember" "name" "java.lang.String"
                                                             (~ (code.text other-sample-string)) (~ value-memberS)))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (text/= other-sample-string (:coerce Text outputT))

                             {#e.Error error}
                             #0)))
            ))))

(host.import: java/lang/Object)

(host.import: (java/util/ArrayList a))

(context: "Member [Method]"
  (<| (times +100)
      (do @
        [sample (|> r.int (:: @ each (|>> int/abs (i/% 100))))
         #let [object-longS (` ["java.lang.Object" (~ (code.int sample))])
               intS (` ["int" ("jvm object cast" "java.lang.Integer" "int"
                               ("jvm convert long-to-int" (~ (code.int sample))))])
               coded-intS (` ["java.lang.String" (~ (code.text (int/encode sample)))])
               array-listS (` ("jvm member invoke constructor" "java.util.ArrayList" (~ intS)))]]
        ($_ seq
            (test "jvm member invoke static"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm member invoke static" "java.lang.Long"
                                                            "decode" "java.lang.Long"
                                                            (~ coded-intS))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (i/= sample (:coerce Int outputT))

                             {#e.Error error}
                             #0)))
            (test "jvm member invoke virtual"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm object cast" "boolean" "java.lang.Boolean"
                                                            ("jvm member invoke virtual" "java.lang.Object" "equals" "boolean"
                                                             (~ (code.int sample)) (~ object-longS)))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (:coerce Bit outputT)

                             {#e.Error error}
                             #0)))
            (test "jvm member invoke interface"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate (` ("jvm object cast" "boolean" "java.lang.Boolean"
                                                            ("jvm member invoke interface" "java.util.Collection" "add" "boolean"
                                                             (~ array-listS) (~ object-longS)))))]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (:coerce Bit outputT)

                             {#e.Error error}
                             #0)))
            (test "jvm member invoke constructor"
                  (|> (do macro.Monad<Meta>
                        [sampleI (expressionT.translate array-listS)]
                        (evalT.eval sampleI))
                      (lang.with-current-module "")
                      (macro.result (io.run! init-jvm))
                      (case> {#e.Success outputT}
                             (host.instance? ArrayList (:coerce Object outputT))

                             {#e.Error error}
                             #0)))
            ))))