}Z4iР,_},\Po
N ҡCs{~d̘1jhYeӧ~6L>w!!I\( S (`?AwOY"
Pȇ jA} :Dǯx DŽ Gzf>},^|H;mڴ1yj QFIϞ=?L8QUȸqo_
6L:wl ͟?_fAMyp>Ԇѩo߾n?#U J3gT?5Ȁ_'LffVZ|!?0B[o%ݺuӛ>+VpG
:-_\POƵ8̳ (@0%C
P Z-xG"99YTjUUDo muuXY`xdPåZzMD݂ {U ~sNa*Wkw"0B:S (@+ 0bP (@
P (5^;3OL
P (@
P ,$ nB
P (@
P-L
P (@
P`V(@
P (@
P )@
P (@
P
(@
P (@
P`{<3(@
P (@
P`B7Y (@
P (@
P{ xϖg (@
P (@
PBpo*u IENDB` clojure-test.generative-435b875/epl.html 0000664 0000000 0000000 00000030536 15127015307 0020223 0 ustar 00root root 0000000 0000000
Eclipse Public License - Version 1.0
Eclipse Public License - v 1.0
THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
AGREEMENT.
1. DEFINITIONS
"Contribution" means:
a) in the case of the initial Contributor, the initial
code and documentation distributed under this Agreement, and
b) in the case of each subsequent Contributor:
i) changes to the Program, and
ii) additions to the Program;
where such changes and/or additions to the Program
originate from and are distributed by that particular Contributor. A
Contribution 'originates' from a Contributor if it was added to the
Program by such Contributor itself or anyone acting on such
Contributor's behalf. Contributions do not include additions to the
Program which: (i) are separate modules of software distributed in
conjunction with the Program under their own license agreement, and (ii)
are not derivative works of the Program.
"Contributor" means any person or entity that distributes
the Program.
"Licensed Patents" mean patent claims licensable by a
Contributor which are necessarily infringed by the use or sale of its
Contribution alone or when combined with the Program.
"Program" means the Contributions distributed in accordance
with this Agreement.
"Recipient" means anyone who receives the Program under
this Agreement, including all Contributors.
2. GRANT OF RIGHTS
a) Subject to the terms of this Agreement, each
Contributor hereby grants Recipient a non-exclusive, worldwide,
royalty-free copyright license to reproduce, prepare derivative works
of, publicly display, publicly perform, distribute and sublicense the
Contribution of such Contributor, if any, and such derivative works, in
source code and object code form.
b) Subject to the terms of this Agreement, each
Contributor hereby grants Recipient a non-exclusive, worldwide,
royalty-free patent license under Licensed Patents to make, use, sell,
offer to sell, import and otherwise transfer the Contribution of such
Contributor, if any, in source code and object code form. This patent
license shall apply to the combination of the Contribution and the
Program if, at the time the Contribution is added by the Contributor,
such addition of the Contribution causes such combination to be covered
by the Licensed Patents. The patent license shall not apply to any other
combinations which include the Contribution. No hardware per se is
licensed hereunder.
c) Recipient understands that although each Contributor
grants the licenses to its Contributions set forth herein, no assurances
are provided by any Contributor that the Program does not infringe the
patent or other intellectual property rights of any other entity. Each
Contributor disclaims any liability to Recipient for claims brought by
any other entity based on infringement of intellectual property rights
or otherwise. As a condition to exercising the rights and licenses
granted hereunder, each Recipient hereby assumes sole responsibility to
secure any other intellectual property rights needed, if any. For
example, if a third party patent license is required to allow Recipient
to distribute the Program, it is Recipient's responsibility to acquire
that license before distributing the Program.
d) Each Contributor represents that to its knowledge it
has sufficient copyright rights in its Contribution, if any, to grant
the copyright license set forth in this Agreement.
3. REQUIREMENTS
A Contributor may choose to distribute the Program in object code
form under its own license agreement, provided that:
a) it complies with the terms and conditions of this
Agreement; and
b) its license agreement:
i) effectively disclaims on behalf of all Contributors
all warranties and conditions, express and implied, including warranties
or conditions of title and non-infringement, and implied warranties or
conditions of merchantability and fitness for a particular purpose;
ii) effectively excludes on behalf of all Contributors
all liability for damages, including direct, indirect, special,
incidental and consequential damages, such as lost profits;
iii) states that any provisions which differ from this
Agreement are offered by that Contributor alone and not by any other
party; and
iv) states that source code for the Program is available
from such Contributor, and informs licensees how to obtain it in a
reasonable manner on or through a medium customarily used for software
exchange.
When the Program is made available in source code form:
a) it must be made available under this Agreement; and
b) a copy of this Agreement must be included with each
copy of the Program.
Contributors may not remove or alter any copyright notices contained
within the Program.
Each Contributor must identify itself as the originator of its
Contribution, if any, in a manner that reasonably allows subsequent
Recipients to identify the originator of the Contribution.
4. COMMERCIAL DISTRIBUTION
Commercial distributors of software may accept certain
responsibilities with respect to end users, business partners and the
like. While this license is intended to facilitate the commercial use of
the Program, the Contributor who includes the Program in a commercial
product offering should do so in a manner which does not create
potential liability for other Contributors. Therefore, if a Contributor
includes the Program in a commercial product offering, such Contributor
("Commercial Contributor") hereby agrees to defend and
indemnify every other Contributor ("Indemnified Contributor")
against any losses, damages and costs (collectively "Losses")
arising from claims, lawsuits and other legal actions brought by a third
party against the Indemnified Contributor to the extent caused by the
acts or omissions of such Commercial Contributor in connection with its
distribution of the Program in a commercial product offering. The
obligations in this section do not apply to any claims or Losses
relating to any actual or alleged intellectual property infringement. In
order to qualify, an Indemnified Contributor must: a) promptly notify
the Commercial Contributor in writing of such claim, and b) allow the
Commercial Contributor to control, and cooperate with the Commercial
Contributor in, the defense and any related settlement negotiations. The
Indemnified Contributor may participate in any such claim at its own
expense.
For example, a Contributor might include the Program in a commercial
product offering, Product X. That Contributor is then a Commercial
Contributor. If that Commercial Contributor then makes performance
claims, or offers warranties related to Product X, those performance
claims and warranties are such Commercial Contributor's responsibility
alone. Under this section, the Commercial Contributor would have to
defend claims against the other Contributors related to those
performance claims and warranties, and if a court requires any other
Contributor to pay any damages as a result, the Commercial Contributor
must pay those damages.
5. NO WARRANTY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
responsible for determining the appropriateness of using and
distributing the Program and assumes all risks associated with its
exercise of rights under this Agreement , including but not limited to
the risks and costs of program errors, compliance with applicable laws,
damage to or loss of data, programs or equipment, and unavailability or
interruption of operations.
6. DISCLAIMER OF LIABILITY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
7. GENERAL
If any provision of this Agreement is invalid or unenforceable under
applicable law, it shall not affect the validity or enforceability of
the remainder of the terms of this Agreement, and without further action
by the parties hereto, such provision shall be reformed to the minimum
extent necessary to make such provision valid and enforceable.
If Recipient institutes patent litigation against any entity
(including a cross-claim or counterclaim in a lawsuit) alleging that the
Program itself (excluding combinations of the Program with other
software or hardware) infringes such Recipient's patent(s), then such
Recipient's rights granted under Section 2(b) shall terminate as of the
date such litigation is filed.
All Recipient's rights under this Agreement shall terminate if it
fails to comply with any of the material terms or conditions of this
Agreement and does not cure such failure in a reasonable period of time
after becoming aware of such noncompliance. If all Recipient's rights
under this Agreement terminate, Recipient agrees to cease use and
distribution of the Program as soon as reasonably practicable. However,
Recipient's obligations under this Agreement and any licenses granted by
Recipient relating to the Program shall continue and survive.
Everyone is permitted to copy and distribute copies of this
Agreement, but in order to avoid inconsistency the Agreement is
copyrighted and may only be modified in the following manner. The
Agreement Steward reserves the right to publish new versions (including
revisions) of this Agreement from time to time. No one other than the
Agreement Steward has the right to modify this Agreement. The Eclipse
Foundation is the initial Agreement Steward. The Eclipse Foundation may
assign the responsibility to serve as the Agreement Steward to a
suitable separate entity. Each new version of the Agreement will be
given a distinguishing version number. The Program (including
Contributions) may always be distributed subject to the version of the
Agreement under which it was received. In addition, after a new version
of the Agreement is published, Contributor may elect to distribute the
Program (including its Contributions) under the new version. Except as
expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
rights or licenses to the intellectual property of any Contributor under
this Agreement, whether expressly, by implication, estoppel or
otherwise. All rights in the Program not expressly granted under this
Agreement are reserved.
This Agreement is governed by the laws of the State of New York and
the intellectual property laws of the United States of America. No party
to this Agreement will bring a legal action under this Agreement more
than one year after the cause of action arose. Each party waives its
rights to a jury trial in any resulting litigation.
clojure-test.generative-435b875/examples/ 0000775 0000000 0000000 00000000000 15127015307 0020364 5 ustar 00root root 0000000 0000000 clojure-test.generative-435b875/examples/hello_world.clj 0000664 0000000 0000000 00000003054 15127015307 0023372 0 ustar 00root root 0000000 0000000 (require
'[clojure.data.generators :as gen]
'[clojure.test.generative :as test :refer (defspec)]
'[clojure.test.generative.runner :as runner])
;; generators have names that shadow core names of things generated
(gen/long)
;; generation is repeatable
(repeatedly
2
#(binding [gen/*rnd* (java.util.Random. 42)]
(gen/short)))
;; generation is composable
(gen/vec gen/short)
;; size is parameterized
(gen/vec gen/short 2)
;; size parameter can of course also be a generator
(gen/vec gen/short (gen/uniform 3 5))
;; generators are in scope as "types" in a defspec
(defspec longs-are-closed-under-increment
inc ;; function under test
[^long l] ;; indicates generation via gen/long
(assert (instance? Long %)))
;; specs are functions
(longs-are-closed-under-increment 4)
;; the next two steps are executed for you by the standard runner...
;; tests are extracted from vars
(def tests (runner/get-tests #'longs-are-closed-under-increment))
(first tests)
;; run test with some generated inputs
(runner/run-one
(first tests)
1000
[42])
(runner/run-n
2
1000
tests)
;; repl-friendly use
(runner/run-vars
2 1000 #'longs-are-closed-under-increment)
;; peek at what defspec tells us
(meta #'longs-are-closed-under-increment)
;; test that will fail
(defspec collections-are-small
count
[^{:tag (gen/vec gen/short (gen/uniform 0 25))} l]
(assert (< % 20)))
;; run as from REPL
(runner/run-vars
2 1000 #'collections-are-small)
(ex-data *e)
;; run as from suite
(runner/run-suite {:threads 1 :msec 500} (runner/get-tests #'collections-are-small))
clojure-test.generative-435b875/pom.xml 0000664 0000000 0000000 00000005605 15127015307 0020071 0 ustar 00root root 0000000 0000000
4.0.0
test.generative
1.1.1
test.generative
Generative test runner for Clojure.
org.clojure
pom.contrib
1.4.0
1.11.4
true
Stuart Halloway
scm:git:git@github.com:clojure/test.generative.git
scm:git:git@github.com:clojure/test.generative.git
git@github.com:clojure/test.generative.git
v1.1.1
sonatype-oss-snapshots
https://oss.sonatype.org/content/repositories/snapshots
org.clojure
tools.namespace
1.5.1
org.clojure
data.generators
1.1.1
maven-invoker-plugin
3.9.1
*/pom.xml
true
clojure:test
-Duser.dir=${basedir}
install
run
com.theoryinpractise
clojure-maven-plugin
1.7.1
-Dclojure.test.generative.runner=clojure.test
bin/test.clj
src/examples/clojure
!.*
true
clojure-test.generative-435b875/src/ 0000775 0000000 0000000 00000000000 15127015307 0017335 5 ustar 00root root 0000000 0000000 clojure-test.generative-435b875/src/examples/ 0000775 0000000 0000000 00000000000 15127015307 0021153 5 ustar 00root root 0000000 0000000 clojure-test.generative-435b875/src/examples/clojure/ 0000775 0000000 0000000 00000000000 15127015307 0022616 5 ustar 00root root 0000000 0000000 clojure-test.generative-435b875/src/examples/clojure/clojure/ 0000775 0000000 0000000 00000000000 15127015307 0024261 5 ustar 00root root 0000000 0000000 clojure-test.generative-435b875/src/examples/clojure/clojure/test/ 0000775 0000000 0000000 00000000000 15127015307 0025240 5 ustar 00root root 0000000 0000000 clojure-test.generative-435b875/src/examples/clojure/clojure/test/array_test.clj 0000664 0000000 0000000 00000004635 15127015307 0030117 0 ustar 00root root 0000000 0000000 ; Copyright (c) Rich Hickey, Stuart Halloway, and contributors.
; 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.
(ns clojure.test.array-test
(:use clojure.test.generative)
(:require [clojure.data.generators :as gen]))
(defn nan-or-=
[a b]
(or (= a b)
(and (Double/isNaN a)
(Double/isNaN b))))
(defmacro array-access-specs
[pdescs]
`(do
~@(map
(fn [[prim comp]]
`(defspec ~(symbol (str prim "-array-access"))
vec
[~(with-meta 'arr {:tag (list (symbol (str prim "-array")) prim)})]
(assert (= (alength ~'arr) (count ~'%)))
(dotimes [~'i (count ~'arr)]
(assert (~comp (aget ~'arr ~'i) (get ~'% ~'i))))))
pdescs)))
(defmacro copy-array-fns
[& types]
`(do
~@(map
(fn [t]
`(defn ~(symbol (str "copy-" t "-array"))
[~'a]
(let [~'copy ~(list (symbol (str t "-array")) 'a)]
(dotimes [~'i (alength ~'a)]
(aset ~'copy ~'i ~(with-meta `(aget ~'a ~'i)
{:tag (symbol (str t "s"))})))
~'copy)))
types)))
(copy-array-fns boolean byte char short int long float double object)
(defmacro aset-specs
[pdescs]
`(do
~@(map
(fn [[prim comp]]
`(defspec ~(symbol (str prim "-aset-spec"))
copy-object-array
[~(with-meta 'arr {:tag (list (symbol (str prim "-array")) prim)})]
(assert (= (alength ~'arr) (alength ~'%)))
(dotimes [~'i (count ~'arr)]
(assert (~comp (aget ~'arr ~'i) (aget ~'% ~'i))))))
pdescs)))
(array-access-specs {int =
long =
float nan-or-=
double nan-or-=
short =
byte =
char =
boolean =})
(aset-specs {int =
long =
float nan-or-=
double nan-or-=
short =
byte =
char =
boolean =})
clojure-test.generative-435b875/src/examples/clojure/clojure/test/core_test.clj 0000664 0000000 0000000 00000006203 15127015307 0027722 0 ustar 00root root 0000000 0000000 ; Copyright (c) Rich Hickey, Stuart Halloway, and contributors.
; 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.
(ns clojure.test.core-test
(:use clojure.test.generative clojure.pprint clojure.data clojure.walk)
(:require [clojure.data.generators :as gen]))
(def ^:private failed-diff-ref (atom nil))
(defmacro
assert=
"Specialization of assert for equality. Uses clojure.data/diff to
report detailed difference in unequal things. You can get the
(last-failed-diff)."
([a b] `(assert= ~a ~b nil))
([a b context]
(when *assert*
`(let [[d1# d2# s#] (clojure.data/diff ~a ~b)
context# (if ~context (str "[" ~context "] ") "")]
(when (or d1# d2#)
(reset! failed-diff-ref [d1# d2# s#])
(throw (new AssertionError (str context# "Items different: " ~a ", " ~b))))))))
(defn last-failed-diff
[]
@failed-diff-ref)
(defn map->case-src
"Returns source for a case statement that works like map m,
with default for missing elements."
[m default]
`(fn [input#]
(case input#
~@(mapcat identity m)
~default)))
(defn map->case-fn
"Create a case statement that works the same as map m,
with default for missing items."
[m default]
(eval (map->case-src m default)))
(defn map->cond-src
[m default]
(list 'fn '[input]
(apply list 'cond
(concat (mapcat (fn [[k v]] [(list '= 'input (list 'quote k))
(list 'quote v)]) m)
[:else default]))))
(defn map->cond-fn
[m default]
(eval (map->cond-src m default)))
(defn case-test-constant
"Generate a test constant that might appear in a case expression."
[]
(gen/one-of gen/long
gen/char
gen/scalar
gen/keyword))
(defspec case-spec
map->case-fn
[^{:tag (hash-map `case-test-constant long)} case-map
^keyword default]
(doseq [k (keys case-map)]
(assert= (% k) (case-map k) k))
(doseq [k (range 100)]
(when-not (contains? case-map k)
(assert= (% k) default k))))
(defspec cond-spec
map->cond-fn
[^{:tag (hash-map `case-test-constant long)} cond-map
^keyword default]
(doseq [k (keys cond-map)]
(assert= (% k) (cond-map k) k))
(doseq [k (range 100)]
(when-not (contains? cond-map k)
(assert= (% k) default k))))
(defn encountered-in-walk
"Returns a frequency map of items encountered while walking
obj, using a walk-fn from e.g. clojure.walk."
[walk-fn obj]
(let [encountered (atom [])]
(walk-fn
(fn [obj] (swap! encountered conj obj) obj)
obj)
(frequencies @encountered)))
(defspec pre-and-post-walk-hit-same-things
identity
[^anything _]
(assert= (encountered-in-walk prewalk %)
(encountered-in-walk postwalk %)))
clojure-test.generative-435b875/src/examples/clojure/clojure/test/math_test.clj 0000664 0000000 0000000 00000007252 15127015307 0027730 0 ustar 00root root 0000000 0000000 ; Copyright (c) Rich Hickey, Stuart Halloway, and contributors.
; 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.
(ns clojure.test.math-test
(:use clojure.test.generative)
(:require
[clojure.data.generators :as gen]
[clojure.test.generative :as tgen]))
(defn integer
"Distribution of integers biased towards the small, but
including all longs."
[]
(gen/one-of #(gen/uniform -1 32) gen/byte gen/short gen/int gen/long))
(defn longable?
[n]
(try
(long n)
true
(catch Exception _)))
(defspec integer-commutative-laws
(partial map identity)
[^{:tag `integer} a ^{:tag `integer} b]
(if (longable? (+' a b))
(assert (= (+ a b) (+ b a)
(+' a b) (+' b a)
(unchecked-add a b) (unchecked-add b a)))
(assert (= (+' a b) (+' b a))))
(if (longable? (*' a b))
(assert (= (* a b) (* b a)
(*' a b) (*' b a)
(unchecked-multiply a b) (unchecked-multiply b a)))
(assert (= (*' a b) (*' b a)))))
(defspec integer-associative-laws
(partial map identity)
[^{:tag `integer} a ^{:tag `integer} b ^{:tag `integer} c]
(if (every? longable? [(+' a b) (+' b c) (+' a b c)])
(assert (= (+ (+ a b) c) (+ a (+ b c))
(+' (+' a b) c) (+' a (+' b c))
(unchecked-add (unchecked-add a b) c) (unchecked-add a (unchecked-add b c))))
(assert (= (+' (+' a b) c) (+' a (+' b c))
(+ (+ (bigint a) b) c) (+ a (+ (bigint b) c)))))
(if (every? longable? [(*' a b) (*' b c) (*' a b c)])
(assert (= (* (* a b) c) (* a (* b c))
(*' (*' a b) c) (*' a (*' b c))
(unchecked-multiply (unchecked-multiply a b) c) (unchecked-multiply a (unchecked-multiply b c))))
(assert (= (*' (*' a b) c) (*' a (*' b c))
(* (* (bigint a) b) c) (* a (* (bigint b) c))))))
(defspec integer-distributive-laws
(partial map identity)
[^{:tag `integer} a ^{:tag `integer} b ^{:tag `integer} c]
(if (every? longable? [(*' a (+' b c)) (+' (*' a b) (*' a c))
(*' a b) (*' a c) (+' b c)])
(assert (= (* a (+ b c)) (+ (* a b) (* a c))
(*' a (+' b c)) (+' (*' a b) (*' a c))
(unchecked-multiply a (+' b c)) (+' (unchecked-multiply a b) (unchecked-multiply a c))))
(assert (= (*' a (+' b c)) (+' (*' a b) (*' a c))
(* a (+ (bigint b) c)) (+ (* (bigint a) b) (* (bigint a) c))))))
(defspec addition-undoes-subtraction
(partial map identity)
[^{:tag `integer} a ^{:tag `integer} b]
(if (longable? (-' a b))
(assert (= a
(-> a (- b) (+ b))
(-> a (unchecked-subtract b) (unchecked-add b)))))
(assert (= a
(-> a (-' b) (+' b)))))
(defspec quotient-and-remainder
(fn [a b] (sort [a b]))
[^{:tag `integer} a ^{:tag `integer} b]
(when-not (zero? (second %))
(let [[a d] %
q (quot a d)
r (rem a d)]
(assert (= a
(+ (* q d) r)
(unchecked-add (unchecked-multiply q d) r))))))
(defn inc'-doesnt-overflow
[a]
(assert (< a (inc' a))))
;; You can mark a var containing "raw" specs with ::tgen/specs to
;; include it in the test suite.
(def ^::tgen/specs
inc'-doesnt-overflow-specs
[{:test 'clojure.test.math-test/inc'-doesnt-overflow
:input-gen #(map vector [Long/MIN_VALUE -1 0 1 Long/MAX_VALUE])}])
clojure-test.generative-435b875/src/main/ 0000775 0000000 0000000 00000000000 15127015307 0020261 5 ustar 00root root 0000000 0000000 clojure-test.generative-435b875/src/main/clojure/ 0000775 0000000 0000000 00000000000 15127015307 0021724 5 ustar 00root root 0000000 0000000 clojure-test.generative-435b875/src/main/clojure/clojure/ 0000775 0000000 0000000 00000000000 15127015307 0023367 5 ustar 00root root 0000000 0000000 clojure-test.generative-435b875/src/main/clojure/clojure/test/ 0000775 0000000 0000000 00000000000 15127015307 0024346 5 ustar 00root root 0000000 0000000 clojure-test.generative-435b875/src/main/clojure/clojure/test/generative.clj 0000664 0000000 0000000 00000006053 15127015307 0027175 0 ustar 00root root 0000000 0000000 ; Copyright (c) Rich Hickey, Stuart Halloway, and contributors.
; 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.
(ns clojure.test.generative
(:require [clojure.walk :as walk]))
(defn- fully-qualified
"Qualify a name used in :tag metadata. Unqualified names are
interpreted in the 'clojure.data.generators, except
for the fn-building symbols fn and fn*."
[n]
(let [ns (cond
(#{'fn*} n) nil
(#{'fn} n) 'clojure.core
(namespace n) (namespace n)
:else 'clojure.data.generators)]
(if ns
(symbol (str ns) (name n))
n)))
(defn- dequote
"Remove the backquotes used to call out user-namespaced forms."
[form]
(walk/prewalk
#(if (and (sequential? %)
(= 2 (count %))
(= 'quote (first %)))
(second %)
%)
form))
(defn- tag->gen
"Convert tag to source code form for a test data generator."
[arg]
(let [form (walk/prewalk (fn [s] (if (symbol? s) (fully-qualified s) s)) (dequote arg))]
(if (seq? form)
(list 'fn '[] form)
form)))
(defmacro defspec
"Defines a function named name that expects args. The defined
function binds '%' to the result of calling fn-to-test with args,
and runs validator-body forms (if any), which have access to both
args and %. The defined function.
Args must have type hints (i.e. :tag metadata), which are
interpreted as instructions for generating test input
data. Unquoted names in type hints are resolved in the
c.t.g.generators namespace, which has generator functions for
common Clojure data types. For example, the following argument list
declares that 'seed' is an int, and that 'iters' is an int in the
uniform distribution from 1 to 100:
[^int seed ^{:tag (uniform 1 100)} iters]
Backquoted names in an argument list are resolved in the current
namespace, allowing arbitrary generators, e.g.
[^{:tag `scary-word} word]
The function c.t.g.runner/run-iter takes a var naming a test, and runs
a single test iteration, generating inputs based on the arg type hints."
[name fn-to-test args & validator-body]
(when-let [missing-tags (->> (map #(list % (-> % meta :tag)) args)
(filter (fn [[_ tag]] (nil? tag)))
seq)]
(throw (IllegalArgumentException. (str "Missing tags for " (seq (map first missing-tags)) " in " name))))
`(defn ~(with-meta name (assoc (meta name)
::arg-fns (into [] (map #(-> % meta :tag tag->gen eval) args))))
~(into [] (map (fn [a#] (with-meta a# (dissoc (meta a#) :tag))) args))
(let [~'% (apply ~fn-to-test ~args)]
~@validator-body
~'%)))
clojure-test.generative-435b875/src/main/clojure/clojure/test/generative/ 0000775 0000000 0000000 00000000000 15127015307 0026477 5 ustar 00root root 0000000 0000000 clojure-test.generative-435b875/src/main/clojure/clojure/test/generative/runner.clj 0000664 0000000 0000000 00000015104 15127015307 0030503 0 ustar 00root root 0000000 0000000 ; Copyright (c) Rich Hickey, Stuart Halloway, and contributors.
; 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.
(ns clojure.test.generative.runner
(:require
[clojure.tools.namespace.find :as ns]
[clojure.data.generators :as gen]
[clojure.test.generative :as tgen]))
(set! *warn-on-reflection* true)
(def ^:private config-mapping
[["clojure.test.generative.threads"
[:nthreads]
read-string
(max 1 (dec (.availableProcessors (Runtime/getRuntime))))]
["clojure.test.generative.msec"
[:msec]
read-string
10000]])
(defn config
"Returns runner configuration derived from system properties."
[]
(reduce
(fn [m [prop path coerce default]]
(let [val (System/getProperty prop)]
(if (seq val)
(assoc-in m path (coerce val))
(assoc-in m path default))))
{}
config-mapping))
(def ^:private ^java.util.Random rnd (java.util.Random. (System/currentTimeMillis)))
(defn- next-seed
[]
(locking rnd
(.nextInt rnd)))
(defprotocol Testable
(get-tests [_]))
(extend-protocol Testable
clojure.lang.Var
(get-tests
[v]
(let [m (meta v)
arg-fns (::tgen/arg-fns m)
specs (::tgen/specs m)]
(cond
arg-fns
[{:test (-> (if-let [ns (.ns v)]
(str ns "/" (.sym v))
(.sym v))
symbol)
:input-gen (fn []
(repeatedly
(fn []
(into [] (map #(%) arg-fns)))))}]
specs
@v))))
(defn- find-vars-in-namespaces
[& nses]
(when nses
(reduce (fn [v ns] (into v (vals (ns-interns ns)))) [] nses)))
(defn- find-vars-in-dirs
[& dirs]
(let [nses (mapcat #(ns/find-namespaces-in-dir (java.io.File. ^String %)) dirs)]
(doseq [ns nses] (require ns))
(apply find-vars-in-namespaces nses)))
(defn- run-one
"Run f (presumably for side effects) repeatedly on n threads,
until msec has passed or somebody throws an exception.
Returns as many status maps as seeds passed in."
[{:keys [test input-gen]} {:keys [msec seeds]}]
(let [f (eval test)
start (System/currentTimeMillis)
futs (mapv
#(future
(try
(binding [gen/*rnd* (java.util.Random. %)]
(loop [iter 0
[input & more] (input-gen)]
(let [status {:iter iter :seed % :test test :input input}]
(if input
(let [failure (try
(apply f input)
nil
(catch Throwable t
(assoc status :exception t) ))
now (System/currentTimeMillis)]
(cond
failure failure
(< now (+ start msec)) (recur (inc iter) more)
:else (select-keys status [:test :seed :iter])))
(assoc status :exhausted true)))))))
seeds)]
(map deref futs)))
(defn- failed?
"Does test result indicate a failure?"
[result]
(contains? result :exception))
(defn- run-n
"Run tests in parallel on nthreads, dividing msec equally between the tests.
Returns a list of maps of :iter, :seed"
[{:keys [nthreads msec]} tests]
(mapcat #(run-one %
{:msec (/ msec (count tests))
:seeds (repeatedly nthreads next-seed)})
tests))
(def ^:private serializer (agent nil))
(defn serialized
"Returns a function that calls f for side effects, async,
serialized by an agent"
([f] (serialized f serializer))
([f agt]
(fn [& args]
(send-off agt
(fn [_]
(try
(apply f args)
(catch Throwable t
(.printStackTrace t)))
nil))
nil)))
(def prf
"Print and flush."
(serialized (fn [s]
(binding [*out* *err*]
(print s)
(flush)))))
(def print-stack-trace
(serialized (fn [^Throwable t] (.printStackTrace t))))
(def sprn (serialized prn))
(defn dir-tests
"Returns all tests in dirs"
[dirs]
(let [load (fn [s] (require s) s)]
(->> (mapcat #(ns/find-namespaces-in-dir (java.io.File. ^String %)) dirs)
(map load)
(apply find-vars-in-namespaces)
(mapcat get-tests))))
(defn inputs
"For interactive use. Returns an infinite sequence of inputs for
a test."
[test]
((:input-gen test)))
(defn run
"Designed for interactive use. Prints results to *out* and throws
on first failure encountered."
[nthreads msec & test-containers]
(doseq [result (run-n {:nthreads nthreads
:msec msec}
(mapcat get-tests test-containers))]
(if (failed? result)
(throw (ex-info "Generative test failed" result))
(prn result))))
(defn run-suite
"Designed for test suite use."
[{:keys [nthreads msec progress]} tests]
(let [progress (or progress #(prf "."))
ret (reduce
(fn [{:keys [failures iters nresults]} result]
(when (:exception result)
(print-stack-trace (:exception result)))
(if (:exception result)
(sprn result)
(progress))
{:failures (+ failures (if (:exception result) 1 0))
:iters (+ iters (:iter result))
:nresults (+ nresults 1)})
{:failures 0 :iters 0 :nresults 0}
(run-n {:nthreads nthreads
:msec msec}
tests))]
(-> ret
(assoc :tests (/ (:nresults ret) nthreads))
(dissoc :nresults))))
(defn -main
"Command line entry point. Calls System.exit!"
[& dirs]
(if (seq dirs)
(try
(let [result (run-suite (config) (dir-tests dirs))]
(println "\n" result)
(System/exit (:failures result)))
(catch Throwable t
(.printStackTrace t)
(System/exit -1))
(finally
(shutdown-agents)))
(do
(println "Specify at least one directory with tests")
(System/exit -1))))