lasercutter: src/clojure/test_clojure/java

comparison src/clojure/test_clojure/java_interop.clj @ 10:ef7dbbd6452c

added clojure source goodness

author	Robert McIntyre <rlm@mit.edu>
date	Sat, 21 Aug 2010 06:25:44 -0400
parents
children

comparison

equal deleted inserted replaced

-:35cf337adfcf
+:ef7dbbd6452c
+;   Copyright (c) Rich Hickey. All rights reserved.
+;   The use and distribution terms for this software are covered by the
+;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;   which can be found in the file epl-v10.html at the root of this distribution.
+;   By using this software in any fashion, you are agreeing to be bound by
+;   the terms of this license.
+;   You must not remove this notice, or any other, from this software.
+; Author: Frantisek Sodomka
+(ns clojure.test-clojure.java-interop
+(:use clojure.test))
+; http://clojure.org/java_interop
+; http://clojure.org/compilation
+(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 ))
+; set!
+; memfn
+(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 )))
+; proxy, proxy-super
+(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} ))
+; Arrays: [alength] aget aset [make-array to-array into-array to-array-2d aclone]
+;   [float-array, int-array, etc]
+;   amap, areduce
+(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)
+; separate test for exceptions (doesn't work with above macro...)
+(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)
+(boolean-array 0)
+(byte-array 0)
+(char-array 0)
+(short-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)
+(boolean-array 1)
+(byte-array 1)
+(char-array 1)
+(short-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)
+(boolean-array 3)
+(byte-array 3)
+(char-array 3)
+(short-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)
+(boolean-array 0)
+(byte-array 0)
+(char-array 0)
+(short-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])
+(boolean-array [true false])
+(byte-array [(byte 1) (byte 2)])
+(char-array [\a \b \c])
+(short-array [(short 1) (short 2)])
+(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]]) ))
+; Type Hints, *warn-on-reflection*
+;   #^ints, #^floats, #^longs, #^doubles
+; Coercions: [int, long, float, double, char, boolean, short, byte]
+;   num
+;   ints/longs/floats/doubles
+(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)))
+;; Note: More coercions in numbers.clj

Mercurial > lasercutter

comparison src/clojure/test_clojure/java_interop.clj @ 10:ef7dbbd6452c