blob: 6ffdff9334e1a254b8dbf9cbc951cd2311b16d81 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
;;; model.lisp - 2025-02-21
;; Copyright (C) 2025 Aryadev Chavali
;; This program is distributed in the hope that it will be useful, but WITHOUT
;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
;; FOR A PARTICULAR PURPOSE. See the GNU General Public License Version 2 for
;; details.
;; You may distribute and modify this code under the terms of the GNU General
;; Public License Version 2, which you should have received a copy of along with
;; this program. If not, please go to <https://www.gnu.org/licenses/>.
;;; Code:
(defpackage cantedraw/tests/model
(:use
:cl :parachute
:cantedraw.lib.macros :cantedraw.lib.functions
:cantedraw.model))
(in-package :cantedraw/tests/model)
(define-test model-test)
(define-test (model-test int->rank)
:depends-on ((cantedraw/tests/macros ->>)
(cantedraw/tests/functions rev-map))
:compile-at :execute
(fail (int->rank nil))
(fail (int->rank "Not a number"))
;; Proving int->rank maps 0-51 to produces 13 ranks, all equally distributed.
(let ((mapping (rev-map #'int->rank (range 0 52))))
;; Prove there are 13 ranks
(is eq 13 (length mapping))
;; Prove every rank is equivalent in length.
(is eq 1 (->> mapping
(mapcar ($>> cdr length))
remove-duplicates
length))
;; Prove Ace, 2, ..., 10, Jack, Queen, King are the 13 ranks.
(true (every #'identity
(->> (list :ace :king :queen :jack)
(append (range 2 11))
(mapcar (lambda (rank) (assoc rank mapping))))))))
(define-test (model-test rank->int)
:depends-on ((cantedraw/tests/macros ->>))
:compile-at :execute
(fail (rank->int nil))
(fail (rank->int 1738))
(fail (rank->int "not a rank"))
(fail (rank->int :still-not-a-rank))
;; Prove ranks are mapped to unique positive integers
(let ((res (->> (list :jack :queen :king :ace)
(append (range 2 11))
(mapcar #'rank->int))))
(true (every #'integerp res))
(true (every #'(lambda (x) (<= 0 x)) res))
(is equal (length res) (length (remove-duplicates res)))))
(define-test (model-test "int->rank and rank->int are complete inverses")
:depends-on (rank->int int->rank)
(let ((int-range (range 0 13))
(rank-range (->> (list :ace :jack :queen :king)
(append (range 2 11)))))
(is equal rank-range
(mapcar ($>> rank->int int->rank) rank-range))
(is equal int-range
(mapcar ($>> int->rank rank->int) int-range))))
(define-test (model-test int->suit)
:depends-on ((cantedraw/tests/macros ->>)
(cantedraw/tests/functions rev-map))
:compile-at :execute
(fail (int->suit nil))
(fail (int->suit "Not a number"))
;; Proving int->suit splits 0-51 perfectly between the 4 suits
(let ((mapping (rev-map #'int->suit (range 0 53))))
(is eq 5 (length mapping))
(let ((spades (alist-val :spades mapping))
(hearts (alist-val :hearts mapping))
(clubs (alist-val :clubs mapping))
(diamonds (alist-val :diamonds mapping))
(jokers (alist-val :joker mapping)))
(is eq 1 (length jokers))
(is eq 1 (->> (list spades hearts clubs diamonds)
(mapcar #'length)
remove-duplicates
length)))))
(define-test (model-test suit->int)
:depends-on ((cantedraw/tests/macros ->>))
:compile-at :execute
(fail (suit->int nil))
(fail (suit->int "not a suit"))
(fail (suit->int :still-not-a-suit))
(fail (suit->int 42069))
;; Prove suits are mapped to unique positive integers
(let ((res (->> (list :diamonds :clubs :hearts :spades :joker)
(mapcar #'suit->int))))
(true (every #'integerp res) "All integers")
(true (every ($>> (<= 0)) res) "All positive")
(is equal (length res) (length (remove-duplicates res)) "Unique mapping")))
(define-test (model-test "int->suit and suit->int are complete inverses")
:depends-on (suit->int int->suit)
(let ((int-range (list 0 13 26 39 52))
(suit-range (list :diamonds :clubs :hearts :spades :joker)))
(is equal suit-range
(mapcar ($>> suit->int int->suit) suit-range))
(is equal int-range
(mapcar ($>> int->suit suit->int) int-range))))
(define-test (model-test int->card)
:depends-on ((cantedraw/tests/functions range))
:compile-at :execute
(fail (int->card nil))
(fail (int->card "Not a number"))
;; Proving int->card maps 0-51 to exactly 52 unique cards
(let ((mapping (mapcar #'int->card (range 0 52))))
(is eq 52 (length (remove-duplicates mapping :test #'equal))
"52 unique elements.")
(true (every #'card-p mapping)
"Every element is a card."))
;; Prove that cards outside of [0, 51] are mapped to jokers (not exhaustive)
(loop :for positive :from 100 :to 200
:for negative :from -200 :to -100
:for inp := (mapcar #'int->card (list positive negative))
:do (true (every #'card-p inp)
"Is a card.")
:do (true (every (lambda (c) (eq :joker (card-suit c))) inp)
"Are jokers.")))
|
