solitare_test.gleam (5232B)
1 import gleam/int 2 import gleam/list 3 import gleam/option.{Some,None} 4 import solitare.{type Card,Card,JokerA,JokerB,Clubs,Hearts,Diamonds,Spades,InvalidCard,new_card,unkeyed_deck,count_cut,count_cut_value,triple_cut,move_joker_a,move_joker_b,move_jokers,read_output,encrypt,decrypt,passphrase_key} 5 import gleeunit 6 import gleam/string 7 8 pub fn main() -> Nil { 9 gleeunit.main() 10 } 11 12 pub fn new_card_test() { 13 let cases = [ 14 #(new_card(JokerA, Some(1)), Error(InvalidCard)), 15 #(new_card(JokerB, Some(1)), Error(InvalidCard)), 16 #(new_card(JokerA, None), Ok(Card(JokerA, None))), 17 #(new_card(JokerB, None), Ok(Card(JokerB, None))), 18 #(new_card(Clubs, Some(1)), Ok(Card(Clubs, Some(1)))), 19 #(new_card(Clubs, Some(13)), Ok(Card(Clubs, Some(13)))), 20 #(new_card(Clubs, None), Error(InvalidCard)), 21 #(new_card(Clubs, Some(0)), Error(InvalidCard)), 22 #(new_card(Clubs, Some(14)), Error(InvalidCard)), 23 #(new_card(Clubs, Some(14)), Error(InvalidCard)), 24 #(new_card(Diamonds, Some(1)), Ok(Card(Diamonds, Some(1)))), 25 #(new_card(Hearts, Some(1)), Ok(Card(Hearts, Some(1)))), 26 #(new_card(Spades, Some(1)), Ok(Card(Spades, Some(1)))), 27 ] 28 list.each(cases, fn (tup) { 29 let actual = tup.0 30 let expected = tup.1 31 assert actual == expected 32 }) 33 } 34 35 pub fn unkeyed_deck_test() { 36 let ud = unkeyed_deck() 37 assert list.first(ud) == Ok(Card(Clubs, Some(1))) 38 assert list.last(ud) == Ok(Card(JokerB, None)) 39 } 40 41 pub fn count_cut_value_test() { 42 let cases = [ 43 #(count_cut_value(Card(JokerB,None)), 53), 44 #(count_cut_value(Card(JokerA,None)), 53), 45 #(count_cut_value(Card(Clubs,Some(12))), 12), 46 #(count_cut_value(Card(Diamonds,Some(5))), 18), 47 #(count_cut_value(Card(Hearts,Some(3))), 29), 48 #(count_cut_value(Card(Spades,Some(13))), 52) 49 ] 50 list.each(cases, fn (tup) { 51 assert tup.0 == tup.1 52 }) 53 } 54 55 pub fn count_cut_test() { 56 let cases = [ 57 #([1, 4, 2, 7, 6, 3], [7, 6, 1, 4, 2, 3]) 58 ] 59 list.each(cases, fn (cas) { 60 let in = make_clubs_deck(cas.0) 61 let exp = make_clubs_deck(cas.1) 62 let act = count_cut(in) 63 assert act == Ok(exp) 64 }) 65 } 66 67 fn make_clubs_deck(lst: List(Int)) -> List(Card) { 68 list.map(lst, fn (i) { 69 Card(Clubs, Some(i)) 70 }) 71 } 72 73 pub fn triple_cut_test() { 74 let cases = [ 75 #("B 5 8 7 1 A 3 9", "3 9 B 5 8 7 1 A"), 76 #("4 B 5 8 7 1 A 3 9", "3 9 B 5 8 7 1 A 4"), 77 #("B 5 8 7 1 A", "B 5 8 7 1 A"), 78 #("3 9 B 5 8 7 1 A", "B 5 8 7 1 A 3 9"), 79 ] 80 list.each(cases, fn (cas) { 81 let #(in_s, exp_s) = cas 82 let in = make_clubs_deck_s(in_s) 83 let exp = make_clubs_deck_s(exp_s) 84 let assert Ok(act) = triple_cut(in) 85 assert act == exp 86 }) 87 } 88 89 fn make_clubs_deck_s(str: String) -> List(Card) { 90 string.split(str, " ") 91 |> list.map(fn (s) { 92 case int.parse(s) { 93 Ok(value) -> Card(Clubs, Some(value)) 94 _ -> { 95 case s { 96 "A" -> Card(JokerA, None) 97 "B" -> Card(JokerB, None) 98 _ -> panic 99 } 100 } 101 } 102 }) 103 } 104 105 pub fn move_joker_a_test() { 106 let cases = [ 107 #("B 5 8 7 1 A 3 9", "B 5 8 7 1 3 A 9"), 108 #("B 5 8 7 1 3 A 9", "B 5 8 7 1 3 9 A"), 109 #("B 5 8 7 1 3 9 A", "B A 5 8 7 1 3 9"), 110 ] 111 list.each(cases, fn (cas) { 112 let #(in_s, exp_s) = cas 113 let in = make_clubs_deck_s(in_s) 114 let exp = make_clubs_deck_s(exp_s) 115 let act = move_joker_a(in) 116 assert act == Ok(exp) 117 }) 118 } 119 120 121 pub fn move_joker_b_test() { 122 let cases = [ 123 #("B 5 8 7 1 A 3 9", "5 8 B 7 1 A 3 9"), 124 #("2 5 8 7 1 B 3 9", "2 5 8 7 1 3 9 B"), 125 #("2 5 8 7 1 3 B 9", "2 B 5 8 7 1 3 9"), 126 #("2 5 8 7 1 3 9 B", "2 5 B 8 7 1 3 9"), 127 ] 128 list.each(cases, fn (cas) { 129 let #(in_s, exp_s) = cas 130 let in = make_clubs_deck_s(in_s) 131 let exp = make_clubs_deck_s(exp_s) 132 let act = move_joker_b(in) 133 assert act == Ok(exp) 134 }) 135 } 136 137 pub fn move_jokers_test() { 138 let cases = [ 139 #("B 5 8 7 1 A 3 9", "5 8 B 7 1 3 A 9"), 140 #("3 A B 8 9 6", "3 A 8 B 9 6"), 141 ] 142 list.each(cases, fn (cas) { 143 let #(in_s, exp_s) = cas 144 let in = make_clubs_deck_s(in_s) 145 let exp = make_clubs_deck_s(exp_s) 146 let act = move_jokers(in) 147 assert act == Ok(exp) 148 }) 149 } 150 151 pub fn read_output_test() { 152 let cases = [ 153 #("3 5 8 7 1 A 3 9", Some(7)), 154 #("3 4 A B 9 6", None), 155 ] 156 list.each(cases, fn (cas) { 157 let #(in_s, exp) = cas 158 let in = make_clubs_deck_s(in_s) 159 let act = read_output(in) 160 assert act == Ok(exp) 161 }) 162 } 163 164 // test case in the doc is wrong as it isn't modulo 26 165 //pub fn generate_keystream_test() { 166 // let deck = unkeyed_deck() 167 // let assert Ok(#(_updated_deck, keystream)) = generate_keystream(deck, 10) 168 // assert keystream == [4, 49, 10, 24, 8, 51, 44, 6, 4, 33] 169 //} 170 171 172 pub fn encrypt_test() { 173 let deck = unkeyed_deck() 174 let act = encrypt(deck, "AAAAAAAAAA") 175 assert act == Ok("EXKYIZSGEH") 176 } 177 178 pub fn decrypt_test() { 179 let deck = unkeyed_deck() 180 let act = decrypt(deck, "EXKYIZSGEH") 181 assert act == Ok("AAAAAAAAAA") 182 } 183 184 pub fn derive_key_test() { 185 let assert Ok(deck) = passphrase_key("FOO") 186 let act = encrypt(deck, "AAAAAAAAAAAAAAA") 187 assert act == Ok("ITHZUJIWGRFARMW") 188 } 189 190 pub fn derive_key_2_test() { 191 let assert Ok(deck) = passphrase_key("CRYPTONOMICON") 192 let act = encrypt(deck, "SOLITAIRE") 193 assert act == Ok("KIRAKSFJAN") 194 } 195 196 197 198 199 200 201 202 203 204