 (ns push.instructions.standard.vectorized_test
   (:require [push.interpreter.core :as i]
-            [push.type.core :as t])
+            [push.type.core :as t]
+            [push.core :as push])
   (:use midje.sweet)
   (:use [push.util.test-helpers])
   (:use [push.type.item.vectorized])
   )
 
 
+;; fixtures
+
 (def foo-type (t/make-type :foo
                            :recognized-by number?
                            :attributes #{:foo}))
 
 (def foos-type (build-vectorized-type foo-type))
 
+(def teeny (-> (push/interpreter :config {:max-collection-size 9})
+               (i/register-type , foos-type)))
+
+;; tests
 
 (fact "foos-type knows some instructions"
   (keys (:instructions foos-type)) =>

     :scalar  '(99)}           :foos-build       {:foos    '([] [1 2 3])
                                                  :foo     '()
                                                  :scalar  '()})


(tabular


    {:foos   '()
     :foo    '(1/2 3.4)
     :scalar '(3 5)}
                             :foos-cyclevector       {:foos '( [1/2 3.4 1/2 3.4 1/2] )
                                                     :foo  '(1/2 3.4)
                                                     :scalar '()}
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    {:foos   '()
     :foo    '(1/2 3.4)
     :scalar '(0 603)}
                             :foos-cyclevector       {:foos '( [1/2 3.4 1/2] )
                                                     :foo  '(1/2 3.4)
                                                     :scalar '()}
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    {:foos   '()
     :foo    '(1/2 3.4)
     :scalar '(-7/2 111)}
                             :foos-cyclevector       {:foos (list
                                                       (into [] (take 111 (cycle [1/2 3.4]))))
                                                     :foo  '(1/2 3.4)
