7514-rust-interpreter-in-clojure/test/rustint/core_test.clj

(ns rustint.core-test
  (:require [clojure.test :refer :all]
            [rustint.core :refer :all]))

(deftest pasar-a-float-test01
  (testing "Test 01 pasar-a-float"
    (is (= (pasar-a-float 10) 10.0))
  )
)

(deftest pasar-a-float-test02
  (testing "Test 02 pasar-a-float"
    (is (= (pasar-a-float "10") 10.0))
  )
)

(deftest pasar-a-float-test03
  (testing "Test 03 pasar-a-float"
    (is (= (pasar-a-float 10.0) 10.0))
  )
)

(deftest pasar-a-float-test04
  (testing "Test 04 pasar-a-float"
    (is (= (pasar-a-float 'a) 'a))
  )
)

(deftest pasar-a-float-test05
  (testing "Test 05 pasar-a-float"
    (is (= (pasar-a-float [10]) [10]))
  )
)

(deftest pasar-a-int-test01
  (testing "Test 01 int pasar-a-int"
    (is (= (pasar-a-int "10") 10))
  )
)

(deftest pasar-a-int-test02
  (testing "Test 02 int pasar-a-int"
    (is (= (pasar-a-int 10.0) 10))
  )
)

(deftest pasar-a-int-test03
  (testing "Test 03 int pasar-a-int"
    (is (= (pasar-a-int 10) 10))
  )
)

(deftest pasar-a-int-test04
  (testing "Test 04 int pasar-a-int"
    (is (= (pasar-a-int 'a) 'a))
  )
)

(deftest pasar-a-int-test05
  (testing "Test 05 int pasar-a-int"
    (is (= (pasar-a-int [10]) [10]))
  )
)

(deftest compatibles-test01
  (testing "Test 01 compatibles?"
    (is (= (compatibles? 'i64 5) true))
  )
)

(deftest compatibles-test02
  (testing "Test 02 compatibles?"
    (is (= (compatibles? 'i64 5.0) false))
  )
)

(deftest compatibles-test03
  (testing "Test 03 compatibles?"
    (is (= (compatibles? 'i64 [5.0]) true))
  )
)

(deftest compatibles-test04
  (testing "Test 04 compatibles?"
    (is (= (compatibles? 'f64 5.0) true))
  )
)

(deftest compatibles-test05
  (testing "Test 05 compatibles?"
    (is (= (compatibles? 'String "Hola") true))
  )
)

(deftest compatibles-test06
  (testing "Test 06 compatibles?"
    (is (= (compatibles? 'bool true) true))
  )
)

(deftest compatibles-test07
  (testing "Test 07 compatibles?"
    (is (= (compatibles? 'bool 1) false))
  )
)

(deftest compatibles-test08
  (testing "Test 08 compatibles?"
    (is (= (compatibles? 'usize 1) true))
  )
)

(deftest compatibles-test09
  (testing "Test 09 compatibles?"
    (is (= (compatibles? 'char \a) true))
  )
)

(deftest compatibles-test10
  (testing "Test 10 compatibles?"
    (is (= (compatibles? 'char 'a) false))
  )
)

(deftest compatibles-test11
  (testing "Test 11 compatibles?"
    (is (= (compatibles? 'char ['a]) true))
  )
)

(deftest dividir-test01
  (testing "Test 01 dividir"
    (is (= (dividir 12 3) 4))
  )
)

(deftest dividir-test02
  (testing "Test 02 dividir"
    (is (= (dividir 12.0 3) 4.0))
  )
)

(deftest dividir-test03
  (testing "Test 03 dividir"
    (is (= (dividir 12 3.0) 4.0))
  )
)

(deftest dividir-test04
  (testing "Test 04h dividir"
    (is (= (dividir 12.0 3.0) 4.0))
  )
)

(deftest dividir-test05
  (testing "Test 05 dividir"
    (is (= (dividir 1 2) 0))
  )
)

(deftest dividir-test06
  (testing "Test 06 dividir"
    (is (= (dividir 1 2.0) 0.5))
  )
)

(deftest identificador-test01
  (testing "Test 01 identificador"
    (is (= (identificador? 'boolean) true))
  )
)

(deftest identificador-test02
  (testing "Test 02 identificador"
    (is (= (identificador? 'bool) false))
  )
)

(deftest identificador-test03
  (testing "Test 03 identificador"
    (is (= (identificador? 'e120) true))
  )
)

(deftest identificador-test04
  (testing "Test 04 identificador"
    (is (= (identificador? '12e0) false))
  )
)

(deftest palabra-reservada-test01
  (testing "Test 01 palabra reservada"
    (is (= (palabra-reservada? 'while) true))
  )
)

(deftest palabra-reservada-test02
  (testing "Test 02 palabra reservada"
    (is (= (palabra-reservada? 'until) false))
  )
)

(deftest palabra-reservada-test03
  (testing "Test 03 palabra reservada"
    (is (= (palabra-reservada? 13) false))
  )
)

(deftest dump-01
  (testing "Test 01 dump"
    (let [
          printed (with-out-str (dump '[[POPREF 2] [PUSHFI 2] MUL [PUSHFI 1] ADD NEG]))
      ]
      (is (= printed "0 [POPREF 2]\n1 [PUSHFI 2]\n2 MUL\n3 [PUSHFI 1]\n4 ADD\n5 NEG\n"
))
    )
  )
)

(deftest dump-01-nil
  (testing "Test 01 dump nil"
    (is (nil? (dump '[[POPREF 2] [PUSHFI 2] MUL [PUSHFI 1] ADD NEG])))
  )
)

(deftest dump-02
  (testing "Test 02 dump"
    (let [
          printed (with-out-str (dump '[HLT]))
      ]
      (is (= printed "0 HLT\n"
))
    )
  )
)

(deftest dump-02-nil
  (testing "Test 02 dump nil"
    (is (nil? (dump '[HLT])))
  )
)

(deftest dump-03
  (testing "Test 03 dump"
    (let [
          printed (with-out-str (dump nil))
      ]
      (is (= printed "0 nil\n"
))
    )
  )
)

(deftest dump-03-nil
  (testing "Test 03 dump nil"
    (is (nil? (dump nil)))
  )
)

(deftest convertir-formato-impresion-01
  (testing "Test 01 convertir-formato-impresion"
    (is (=
         (convertir-formato-impresion '("Hola, mundo!"))
         '("Hola, mundo!")
        )
    )
  )
)

(deftest convertir-formato-impresion-01
  (testing "Test 01 convertir-formato-impresion"
    (is (=
         (convertir-formato-impresion '("Hola, mundo 2!"))
         '("Hola, mundo 2!")
        )
    )
  )
)

(deftest get-rust-formatters-01
  (testing "Test 01 get-rust-formatters"
    (is (=
          (get-rust-formatters "Hola, Mundo!")
          '()
        )
    )
  )
)

(deftest get-rust-formatters-02
  (testing "Test 02 get-rust-formatters"
    (is (=
          (get-rust-formatters "- My name is {}, James {}.\n- Hello, {}{}{}!")
          '(nil nil nil nil nil)
        )
    )
  )
)

(deftest get-rust-formatters-03
  (testing "Test 03 get-rust-formatters"
    (is (=
          (get-rust-formatters "{} elevado a la {} es\t{}")
          '(nil nil nil)
        )
    )
  )
)

(deftest get-rust-formatters-04
  (testing "Test 04 get-rust-formatters"
    (is (=
          (get-rust-formatters "Las raices cuadradas de {} son +{:.8} y -{:.8}")
          '(nil ".8" ".8")
        )
    )
  )
)

(deftest test-especificador-formato-01
  (testing "Test 01 especificador formato"
    (is (=
          (especificador-formato "Bond" nil)
          "%s"
        )
    )
  )
)