(ns clojure.test-clojure.java-interop

(:use clojure.test))

(deftest test-dot

; (.instanceMember instance args*)

(are [x] (= x "FRED")

(.toUpperCase "fred")

(. "fred" toUpperCase)

(. "fred" (toUpperCase)) )

(are [x] (= x true)

(.startsWith "abcde" "ab")

(. "abcde" startsWith "ab")

(. "abcde" (startsWith "ab")) )

; (.instanceMember Classname args*)

(are [x] (= x "java.lang.String")

(.getName String)

(. (identity String) getName)

(. (identity String) (getName)) )

; (Classname/staticMethod args*)

(are [x] (= x 7)

(Math/abs -7)

(. Math abs -7)

(. Math (abs -7)) )

; Classname/staticField

(are [x] (= x 2147483647)

Integer/MAX_VALUE

(. Integer MAX_VALUE) ))

(deftest test-double-dot

(is (= (.. System (getProperties) (get "os.name"))

(. (. System (getProperties)) (get "os.name")))))

(deftest test-doto

(let [m (doto (new java.util.HashMap)

(.put "a" 1)

(.put "b" 2))]

(are [x y] (= x y)

(class m) java.util.HashMap

m {"a" 1 "b" 2} )))

(deftest test-new

; Integer

(are [expr cls value] (and (= (class expr) cls)

(= expr value))

(new java.lang.Integer 42) java.lang.Integer 42

(java.lang.Integer. 123) java.lang.Integer 123 )

; Date

(are [x] (= (class x) java.util.Date)

(new java.util.Date)

(java.util.Date.) ))

(deftest test-instance?

; evaluation

(are [x y] (= x y)

(instance? java.lang.Integer (+ 1 2)) true

(instance? java.lang.Long (+ 1 2)) false )

; different types

(are [type literal] (instance? literal type)

1 java.lang.Integer

1.0 java.lang.Double

1M java.math.BigDecimal

\a java.lang.Character

"a" java.lang.String )

; it is an int, nothing else

(are [x y] (= (instance? x 42) y)

java.lang.Integer true

java.lang.Long false

java.lang.Character false

java.lang.String false ))

(deftest test-bean

(let [b (bean java.awt.Color/black)]

(are [x y] (= x y)

(map? b) true

(:red b) 0

(:green b) 0

(:blue b) 0

(:RGB b) -16777216

(:alpha b) 255

(:transparency b) 1

(:class b) java.awt.Color )))

(deftest test-bases

(are [x y] (= x y)

(bases java.lang.Math)

(list java.lang.Object)

(bases java.lang.Integer)

(list java.lang.Number java.lang.Comparable) ))

(deftest test-supers

(are [x y] (= x y)

(supers java.lang.Math)

#{java.lang.Object}

(supers java.lang.Integer)

#{java.lang.Number java.lang.Object

java.lang.Comparable java.io.Serializable} ))

(defmacro deftest-type-array [type-array type]

`(deftest ~(symbol (str "test-" type-array))

; correct type

(is (= (class (first (~type-array [1 2]))) (class (~type 1))))

; given size (and empty)

(are [x] (and (= (alength (~type-array x)) x)

(= (vec (~type-array x)) (repeat x 0)))

0 1 5 )

; copy of a sequence

(are [x] (and (= (alength (~type-array x)) (count x))

(= (vec (~type-array x)) x))

[1]

[1 -2 3 0 5] )

; given size and init-value

(are [x] (and (= (alength (~type-array x 42)) x)

(= (vec (~type-array x 42)) (repeat x 42)))

0 1 5 )

; given size and init-seq

(are [x y z] (and (= (alength (~type-array x y)) x)

(= (vec (~type-array x y)) z))

0 [] []

0 [1] []

0 [1 2 3] []

1 [] [0]

1 [1] [1]

1 [1 2 3] [1]

5 [] [0 0 0 0 0]

5 [1] [1 0 0 0 0]

5 [1 2 3] [1 2 3 0 0]

5 [1 2 3 4 5] [1 2 3 4 5]

5 [1 2 3 4 5 6 7] [1 2 3 4 5] )))

(deftest-type-array int-array int)

(deftest-type-array long-array long)

(deftest-type-array float-array float)

(deftest-type-array double-array double)

(deftest test-type-array-exceptions

(are [x] (thrown? NegativeArraySizeException x)

(int-array -1)

(long-array -1)

(float-array -1)

(double-array -1) ))

(deftest test-make-array

; negative size

(is (thrown? NegativeArraySizeException (make-array Integer -1)))

; one-dimensional

(are [x] (= (alength (make-array Integer x)) x)

0 1 5 )

(let [a (make-array Integer 5)]

(aset a 3 42)

(are [x y] (= x y)

(aget a 3) 42

(class (aget a 3)) Integer ))

; multi-dimensional

(let [a (make-array Integer 3 2 4)]

(aset a 0 1 2 987)

(are [x y] (= x y)

(alength a) 3

(alength (first a)) 2

(alength (first (first a))) 4

(aget a 0 1 2) 987

(class (aget a 0 1 2)) Integer )))

(deftest test-to-array

(let [v [1 "abc" :kw \c []]

a (to-array v)]

(are [x y] (= x y)

; length

(alength a) (count v)

; content

(vec a) v

(class (aget a 0)) (class (nth v 0))

(class (aget a 1)) (class (nth v 1))

(class (aget a 2)) (class (nth v 2))

(class (aget a 3)) (class (nth v 3))

(class (aget a 4)) (class (nth v 4)) ))

; different kinds of collections

(are [x] (and (= (alength (to-array x)) (count x))

(= (vec (to-array x)) (vec x)))

()

'(1 2)

[]

[1 2]

(sorted-set)

(sorted-set 1 2)

(int-array 0)

(int-array [1 2 3])

(to-array [])

(to-array [1 2 3]) ))

(deftest test-into-array

; compatible types only

(is (thrown? IllegalArgumentException (into-array [1 "abc" :kw])))

(is (thrown? IllegalArgumentException (into-array [1.2 4])))

(is (thrown? IllegalArgumentException (into-array [(byte 2) (short 3)])))

; simple case

(let [v [1 2 3 4 5]

a (into-array v)]

(are [x y] (= x y)

(alength a) (count v)

(vec a) v

(class (first a)) (class (first v)) ))

; given type

(let [a (into-array Integer/TYPE [(byte 2) (short 3) (int 4)])]

(are [x] (= x Integer)

(class (aget a 0))

(class (aget a 1))

(class (aget a 2)) ))

; different kinds of collections

(are [x] (and (= (alength (into-array x)) (count x))

(= (vec (into-array x)) (vec x))

(= (alength (into-array Integer/TYPE x)) (count x))

(= (vec (into-array Integer/TYPE x)) (vec x)))

()

'(1 2)

[]

[1 2]

(sorted-set)

(sorted-set 1 2)

(int-array 0)

(int-array [1 2 3])

(to-array [])

(to-array [1 2 3]) ))

(deftest test-to-array-2d

; needs to be a collection of collection(s)

(is (thrown? Exception (to-array-2d [1 2 3])))

; ragged array

(let [v [[1] [2 3] [4 5 6]]

a (to-array-2d v)]

(are [x y] (= x y)

(alength a) (count v)

(alength (aget a 0)) (count (nth v 0))

(alength (aget a 1)) (count (nth v 1))

(alength (aget a 2)) (count (nth v 2))

(vec (aget a 0)) (nth v 0)

(vec (aget a 1)) (nth v 1)

(vec (aget a 2)) (nth v 2) ))

; empty array

(let [a (to-array-2d [])]

(are [x y] (= x y)

(alength a) 0

(vec a) [] )))

(deftest test-alength

(are [x] (= (alength x) 0)

(int-array 0)

(long-array 0)

(float-array 0)

(double-array 0)

(make-array Integer/TYPE 0)

(to-array [])

(into-array [])

(to-array-2d []) )

(are [x] (= (alength x) 1)

(int-array 1)

(long-array 1)

(float-array 1)

(double-array 1)

(make-array Integer/TYPE 1)

(to-array [1])

(into-array [1])

(to-array-2d [[1]]) )

(are [x] (= (alength x) 3)

(int-array 3)

(long-array 3)

(float-array 3)

(double-array 3)

(make-array Integer/TYPE 3)

(to-array [1 "a" :k])

(into-array [1 2 3])

(to-array-2d [[1] [2 3] [4 5 6]]) ))

(deftest test-aclone

; clone all arrays except 2D

(are [x] (and (= (alength (aclone x)) (alength x))

(= (vec (aclone x)) (vec x)))

(int-array 0)

(long-array 0)

(float-array 0)

(double-array 0)

(make-array Integer/TYPE 0)

(to-array [])

(into-array [])

(int-array [1 2 3])

(long-array [1 2 3])

(float-array [1 2 3])

(double-array [1 2 3])

(make-array Integer/TYPE 3)

(to-array [1 "a" :k])

(into-array [1 2 3]) )

; clone 2D

(are [x] (and (= (alength (aclone x)) (alength x))

(= (map alength (aclone x)) (map alength x))

(= (map vec (aclone x)) (map vec x)))

(to-array-2d [])

(to-array-2d [[1] [2 3] [4 5 6]]) ))

(deftest test-boolean

(are [x y] (and (instance? java.lang.Boolean (boolean x))

(= (boolean x) y))

nil false

false false

true true

0 true

1 true

() true

[1] true

"" true

\space true

:kw true ))

(deftest test-char

; int -> char

(is (instance? java.lang.Character (char 65)))

; char -> char

(is (instance? java.lang.Character (char \a)))

(is (= (char \a) \a)))