Mercurial > lasercutter

     1 ;   Copyright (c) Rich Hickey. All rights reserved.

     2 ;   The use and distribution terms for this software are covered by the

     3 ;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)

     4 ;   which can be found in the file epl-v10.html at the root of this distribution.

     5 ;   By using this software in any fashion, you are agreeing to be bound by

     6 ;   the terms of this license.

     7 ;   You must not remove this notice, or any other, from this software.

     8 

     9 ; Author: Stuart Halloway, Daniel Solano Gómez

    10 

    11 (ns clojure.test-clojure.vectors

    12   (:use clojure.test))

    13 

    14 (deftest test-reversed-vec

    15   (let [r (range 6)

    16         v (into (vector-of :int) r)

    17         reversed (.rseq v)]

    18     (testing "returns the right impl"

    19       (is (= clojure.lang.APersistentVector$RSeq (class reversed))))

    20     (testing "RSeq methods"

    21       (is (= [5 4 3 2 1 0] reversed))

    22       (is (= 5 (.index reversed)))

    23       (is (= 5 (.first reversed)))

    24       (is (= [4 3 2 1 0] (.next reversed)))

    25       (is (= [3 2 1 0] (.. reversed next next)))

    26       (is (= 6 (.count reversed))))

    27     (testing "clojure calling through"

    28       (is (= 5 (first reversed)))

    29       (is (= 5 (nth reversed 0))))

    30     (testing "empty reverses to nil"

    31       (is (nil? (.. v empty rseq))))))

    32 

    33 (deftest test-vecseq

    34   (let [r (range 100)

    35         vs (into (vector-of :int) r)

    36         vs-1 (next vs)

    37         vs-32 (.chunkedNext (seq vs))]

    38     (testing "="

    39       (are [a b] (= a b)

    40            vs vs

    41            vs-1 vs-1

    42            vs-32 vs-32)

    43       (are [a b] (not= a b)

    44            vs vs-1

    45            vs-1 vs

    46            vs vs-32

    47            vs-32 vs))

    48     (testing "IPersistentCollection.empty"

    49       (are [a] (identical? clojure.lang.PersistentList/EMPTY (.empty (seq a)))

    50            vs vs-1 vs-32))

    51     (testing "IPersistentCollection.cons"

    52       (are [result input] (= result (.cons input :foo))

    53            [:foo 1] (seq (into (vector-of :int) [1]))))

    54     (testing "IPersistentCollection.count"

    55       (are [ct s] (= ct (.count (seq s)))

    56            100 vs

    57            99 vs-1

    58            68 vs-32)

    59       ;; can't manufacture this scenario: ASeq defers to Counted, but

    60       ;; LazySeq doesn't, so Counted never gets checked on reified seq below

    61       #_(testing "hops to counted when available"

    62         (is (= 200

    63                (.count (concat

    64                         (seq vs)

    65                         (reify clojure.lang.ISeq

    66                                (seq [this] this)

    67                                clojure.lang.Counted

    68                                (count [_] 100))))))))

    69     (testing "IPersistentCollection.equiv"

    70       (are [a b] (true? (.equiv a b))

    71            vs vs

    72            vs-1 vs-1

    73            vs-32 vs-32

    74            vs r)

    75       (are [a b] (false? (.equiv a b))

    76            vs vs-1

    77            vs-1 vs

    78            vs vs-32

    79            vs-32 vs

    80            vs nil))))

    81 

    82 (deftest test-vec-compare

    83   (let [nums      (range 1 100)

    84         ; randomly replaces a single item with the given value

    85         rand-replace  (fn[val]

    86                         (let [r (rand-int 99)]

    87                           (concat (take r nums) [val] (drop (inc r) nums))))

    88         ; all num sequences in map

    89         num-seqs      {:standard       nums

    90                        :empty          '()

    91                        ; different lengths

    92                        :longer         (concat nums [100])

    93                        :shorter        (drop-last nums)

    94                        ; greater by value

    95                        :first-greater  (concat [100] (next nums))

    96                        :last-greater   (concat (drop-last nums) [100])

    97                        :rand-greater-1 (rand-replace 100)

    98                        :rand-greater-2 (rand-replace 100)

    99                        :rand-greater-3 (rand-replace 100)

   100                        ; lesser by value

   101                        :first-lesser   (concat [0] (next nums))

   102                        :last-lesser    (concat (drop-last nums) [0])

   103                        :rand-lesser-1  (rand-replace 0)

   104                        :rand-lesser-2  (rand-replace 0)

   105                        :rand-lesser-3  (rand-replace 0)}

   106         ; a way to create compare values based on num-seqs

   107         create-vals   (fn[base-val]

   108                         (zipmap (keys num-seqs)

   109                                 (map #(into base-val %1) (vals num-seqs))))

   110         ; Vecs made of int primitives

   111         int-vecs      (create-vals (vector-of :int))

   112         ; Vecs made of long primitives

   113         long-vecs     (create-vals (vector-of :long))

   114         ; standard boxing vectors

   115         regular-vecs  (create-vals [])

   116         ; the standard int Vec for comparisons

   117         int-vec       (:standard int-vecs)]

   118     (testing "compare"

   119       (testing "identical"

   120         (is (= 0 (compare int-vec int-vec))))

   121       (testing "equivalent"

   122         (are [x y] (= 0 (compare x y))

   123              ; standard

   124              int-vec (:standard long-vecs)

   125              (:standard long-vecs) int-vec

   126              int-vec (:standard regular-vecs)

   127              (:standard regular-vecs) int-vec

   128              ; empty

   129              (:empty int-vecs) (:empty long-vecs)

   130              (:empty long-vecs) (:empty int-vecs)))

   131       (testing "lesser"

   132         (are [x] (= -1 (compare int-vec x))

   133              (:longer int-vecs)

   134              (:longer long-vecs)

   135              (:longer regular-vecs)

   136              (:first-greater int-vecs)

   137              (:first-greater long-vecs)

   138              (:first-greater regular-vecs)

   139              (:last-greater int-vecs)

   140              (:last-greater long-vecs)

   141              (:last-greater regular-vecs)

   142              (:rand-greater-1 int-vecs)

   143              (:rand-greater-1 long-vecs)

   144              (:rand-greater-1 regular-vecs)

   145              (:rand-greater-2 int-vecs)

   146              (:rand-greater-2 long-vecs)

   147              (:rand-greater-2 regular-vecs)

   148              (:rand-greater-3 int-vecs)

   149              (:rand-greater-3 long-vecs)

   150              (:rand-greater-3 regular-vecs))

   151         (are [x] (= -1 (compare x int-vec))

   152              nil

   153              (:empty int-vecs)

   154              (:empty long-vecs)

   155              (:empty regular-vecs)

   156              (:shorter int-vecs)

   157              (:shorter long-vecs)

   158              (:shorter regular-vecs)

   159              (:first-lesser int-vecs)

   160              (:first-lesser long-vecs)

   161              (:first-lesser regular-vecs)

   162              (:last-lesser int-vecs)

   163              (:last-lesser long-vecs)

   164              (:last-lesser regular-vecs)

   165              (:rand-lesser-1 int-vecs)

   166              (:rand-lesser-1 long-vecs)

   167              (:rand-lesser-1 regular-vecs)

   168              (:rand-lesser-2 int-vecs)

   169              (:rand-lesser-2 long-vecs)

   170              (:rand-lesser-2 regular-vecs)

   171              (:rand-lesser-3 int-vecs)

   172              (:rand-lesser-3 long-vecs)

   173              (:rand-lesser-3 regular-vecs)))

   174       (testing "greater"

   175         (are [x] (= 1 (compare int-vec x))

   176              nil

   177              (:empty int-vecs)

   178              (:empty long-vecs)

   179              (:empty regular-vecs)

   180              (:shorter int-vecs)

   181              (:shorter long-vecs)

   182              (:shorter regular-vecs)

   183              (:first-lesser int-vecs)

   184              (:first-lesser long-vecs)

   185              (:first-lesser regular-vecs)

   186              (:last-lesser int-vecs)

   187              (:last-lesser long-vecs)

   188              (:last-lesser regular-vecs)

   189              (:rand-lesser-1 int-vecs)

   190              (:rand-lesser-1 long-vecs)

   191              (:rand-lesser-1 regular-vecs)

   192              (:rand-lesser-2 int-vecs)

   193              (:rand-lesser-2 long-vecs)

   194              (:rand-lesser-2 regular-vecs)

   195              (:rand-lesser-3 int-vecs)

   196              (:rand-lesser-3 long-vecs)

   197              (:rand-lesser-3 regular-vecs))

   198         (are [x] (= 1 (compare x int-vec))

   199              (:longer int-vecs)

   200              (:longer long-vecs)

   201              (:longer regular-vecs)

   202              (:first-greater int-vecs)

   203              (:first-greater long-vecs)

   204              (:first-greater regular-vecs)

   205              (:last-greater int-vecs)

   206              (:last-greater long-vecs)

   207              (:last-greater regular-vecs)

   208              (:rand-greater-1 int-vecs)

   209              (:rand-greater-1 long-vecs)

   210              (:rand-greater-1 regular-vecs)

   211              (:rand-greater-2 int-vecs)

   212              (:rand-greater-2 long-vecs)

   213              (:rand-greater-2 regular-vecs)

   214              (:rand-greater-3 int-vecs)

   215              (:rand-greater-3 long-vecs)

   216              (:rand-greater-3 regular-vecs))))

   217     (testing "Comparable.compareTo"

   218       (testing "incompatible"

   219         (is (thrown? NullPointerException (.compareTo int-vec nil)))

   220         (are [x] (thrown? ClassCastException (.compareTo int-vec x))

   221              '()

   222              {}

   223              #{}

   224              (sorted-set)

   225              (sorted-map)

   226              nums

   227              1))

   228       (testing "identical"

   229         (is (= 0 (.compareTo int-vec int-vec))))

   230       (testing "equivalent"

   231         (are [x] (= 0 (.compareTo int-vec x))

   232              (:standard long-vecs)

   233              (:standard regular-vecs)))

   234       (testing "lesser"

   235         (are [x] (= -1 (.compareTo int-vec x))

   236              (:longer int-vecs)

   237              (:longer long-vecs)

   238              (:longer regular-vecs)

   239              (:first-greater int-vecs)

   240              (:first-greater long-vecs)

   241              (:first-greater regular-vecs)

   242              (:last-greater int-vecs)

   243              (:last-greater long-vecs)

   244              (:last-greater regular-vecs)

   245              (:rand-greater-1 int-vecs)

   246              (:rand-greater-1 long-vecs)

   247              (:rand-greater-1 regular-vecs)

   248              (:rand-greater-2 int-vecs)

   249              (:rand-greater-2 long-vecs)

   250              (:rand-greater-2 regular-vecs)

   251              (:rand-greater-3 int-vecs)

   252              (:rand-greater-3 long-vecs)

   253              (:rand-greater-3 regular-vecs)))

   254       (testing "greater"

   255         (are [x] (= 1 (.compareTo int-vec x))

   256              (:empty int-vecs)

   257              (:empty long-vecs)

   258              (:empty regular-vecs)

   259              (:shorter int-vecs)

   260              (:shorter long-vecs)

   261              (:shorter regular-vecs)

   262              (:first-lesser int-vecs)

   263              (:first-lesser long-vecs)

   264              (:first-lesser regular-vecs)

   265              (:last-lesser int-vecs)

   266              (:last-lesser long-vecs)

   267              (:last-lesser regular-vecs)

   268              (:rand-lesser-1 int-vecs)

   269              (:rand-lesser-1 long-vecs)

   270              (:rand-lesser-1 regular-vecs)

   271              (:rand-lesser-2 int-vecs)

   272              (:rand-lesser-2 long-vecs)

   273              (:rand-lesser-2 regular-vecs)

   274              (:rand-lesser-3 int-vecs)

   275              (:rand-lesser-3 long-vecs)

   276              (:rand-lesser-3 regular-vecs))))))

   277 

   278 (deftest test-vec-associative

   279   (let [empty-v (vector-of :long)

   280         v       (into empty-v (range 1 6))]

   281     (testing "Associative.containsKey"

   282       (are [x] (.containsKey v x)

   283            0 1 2 3 4)

   284       (are [x] (not (.containsKey v x))

   285            -1 -100 nil [] "" #"" #{} 5 100)

   286       (are [x] (not (.containsKey empty-v x))

   287            0 1))

   288     (testing "contains?"

   289       (are [x] (contains? v x)

   290            0 2 4)

   291       (are [x] (not (contains? v x))

   292            -1 -100 nil "" 5 100)

   293       (are [x] (not (contains? empty-v x))

   294            0 1))

   295     (testing "Associative.entryAt"

   296       (are [idx val] (= (clojure.lang.MapEntry. idx val)

   297                         (.entryAt v idx))

   298            0 1

   299            2 3

   300            4 5)

   301       (are [idx] (nil? (.entryAt v idx))

   302            -5 -1 5 10 nil "")

   303       (are [idx] (nil? (.entryAt empty-v idx))

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