Skip to content

Commit 62522c3

Browse files
ErikSchierboomrobkeim
ErikSchierboom
authored and
robkeim
committed
Simplify canonical data types (#430)
* Make expected property use properties property * Working on simplifying canonical data types * Remove ToEnumerable * Fix complex numbers generator * Simplify generators * Simplify constructor input handling * Make Input and ConstructorInput use Properties field * Further simplifications
1 parent 8823afd commit 62522c3

37 files changed

Lines changed: 316 additions & 364 deletions

‎exercises/book-store/BookStoreTest.cs‎

Lines changed: 26 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -7,91 +7,91 @@ public class BookStoreTest
77
[Fact]
88
public void Only_a_single_book()
99
{
10-
var input = new[] { 1 };
11-
Assert.Equal(8, BookStore.Total(input));
10+
var basket = new[] { 1 };
11+
Assert.Equal(8, BookStore.Total(basket));
1212
}
1313

1414
[Fact(Skip = "Remove to run test")]
1515
public void Two_of_the_same_book()
1616
{
17-
var input = new[] { 2, 2 };
18-
Assert.Equal(16, BookStore.Total(input));
17+
var basket = new[] { 2, 2 };
18+
Assert.Equal(16, BookStore.Total(basket));
1919
}
2020

2121
[Fact(Skip = "Remove to run test")]
2222
public void Empty_basket()
2323
{
24-
var input = new int[0];
25-
Assert.Equal(0, BookStore.Total(input));
24+
var basket = new int[0];
25+
Assert.Equal(0, BookStore.Total(basket));
2626
}
2727

2828
[Fact(Skip = "Remove to run test")]
2929
public void Two_different_books()
3030
{
31-
var input = new[] { 1, 2 };
32-
Assert.Equal(15.2, BookStore.Total(input));
31+
var basket = new[] { 1, 2 };
32+
Assert.Equal(15.2, BookStore.Total(basket));
3333
}
3434

3535
[Fact(Skip = "Remove to run test")]
3636
public void Three_different_books()
3737
{
38-
var input = new[] { 1, 2, 3 };
39-
Assert.Equal(21.6, BookStore.Total(input));
38+
var basket = new[] { 1, 2, 3 };
39+
Assert.Equal(21.6, BookStore.Total(basket));
4040
}
4141

4242
[Fact(Skip = "Remove to run test")]
4343
public void Four_different_books()
4444
{
45-
var input = new[] { 1, 2, 3, 4 };
46-
Assert.Equal(25.6, BookStore.Total(input));
45+
var basket = new[] { 1, 2, 3, 4 };
46+
Assert.Equal(25.6, BookStore.Total(basket));
4747
}
4848

4949
[Fact(Skip = "Remove to run test")]
5050
public void Five_different_books()
5151
{
52-
var input = new[] { 1, 2, 3, 4, 5 };
53-
Assert.Equal(30, BookStore.Total(input));
52+
var basket = new[] { 1, 2, 3, 4, 5 };
53+
Assert.Equal(30, BookStore.Total(basket));
5454
}
5555

5656
[Fact(Skip = "Remove to run test")]
5757
public void Two_groups_of_four_is_cheaper_than_group_of_five_plus_group_of_three()
5858
{
59-
var input = new[] { 1, 1, 2, 2, 3, 3, 4, 5 };
60-
Assert.Equal(51.2, BookStore.Total(input));
59+
var basket = new[] { 1, 1, 2, 2, 3, 3, 4, 5 };
60+
Assert.Equal(51.2, BookStore.Total(basket));
6161
}
6262

6363
[Fact(Skip = "Remove to run test")]
6464
public void Group_of_four_plus_group_of_two_is_cheaper_than_two_groups_of_three()
6565
{
66-
var input = new[] { 1, 1, 2, 2, 3, 4 };
67-
Assert.Equal(40.8, BookStore.Total(input));
66+
var basket = new[] { 1, 1, 2, 2, 3, 4 };
67+
Assert.Equal(40.8, BookStore.Total(basket));
6868
}
6969

7070
[Fact(Skip = "Remove to run test")]
7171
public void Two_each_of_first_4_books_and_1_copy_each_of_rest()
7272
{
73-
var input = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5 };
74-
Assert.Equal(55.6, BookStore.Total(input));
73+
var basket = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5 };
74+
Assert.Equal(55.6, BookStore.Total(basket));
7575
}
7676

7777
[Fact(Skip = "Remove to run test")]
7878
public void Two_copies_of_each_book()
7979
{
80-
var input = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5 };
81-
Assert.Equal(60, BookStore.Total(input));
80+
var basket = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5 };
81+
Assert.Equal(60, BookStore.Total(basket));
8282
}
8383

8484
[Fact(Skip = "Remove to run test")]
8585
public void Three_copies_of_first_book_and_2_each_of_remaining()
8686
{
87-
var input = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1 };
88-
Assert.Equal(68, BookStore.Total(input));
87+
var basket = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1 };
88+
Assert.Equal(68, BookStore.Total(basket));
8989
}
9090

9191
[Fact(Skip = "Remove to run test")]
9292
public void Three_each_of_first_2_books_and_2_each_of_remaining_books()
9393
{
94-
var input = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2 };
95-
Assert.Equal(75.2, BookStore.Total(input));
94+
var basket = new[] { 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 1, 2 };
95+
Assert.Equal(75.2, BookStore.Total(basket));
9696
}
9797
}

‎exercises/complex-numbers/ComplexNumbersTest.cs‎

Lines changed: 38 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -52,116 +52,116 @@ public void Imaginary_unit()
5252
{
5353
var sut = new ComplexNumber(0, 1);
5454
var expected = new ComplexNumber(-1, 0);
55-
Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 1)).Real(), 15);
56-
Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 1)).Imaginary(), 15);
55+
Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 1)).Real(), precision: 15);
56+
Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 1)).Imaginary(), precision: 15);
5757
}
5858

5959
[Fact(Skip = "Remove to run test")]
6060
public void Add_purely_real_numbers()
6161
{
6262
var sut = new ComplexNumber(1, 0);
6363
var expected = new ComplexNumber(3, 0);
64-
Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(2, 0)).Real(), 15);
65-
Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(2, 0)).Imaginary(), 15);
64+
Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(2, 0)).Real(), precision: 15);
65+
Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(2, 0)).Imaginary(), precision: 15);
6666
}
6767

6868
[Fact(Skip = "Remove to run test")]
6969
public void Add_purely_imaginary_numbers()
7070
{
7171
var sut = new ComplexNumber(0, 1);
7272
var expected = new ComplexNumber(0, 3);
73-
Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(0, 2)).Real(), 15);
74-
Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(0, 2)).Imaginary(), 15);
73+
Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(0, 2)).Real(), precision: 15);
74+
Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(0, 2)).Imaginary(), precision: 15);
7575
}
7676

7777
[Fact(Skip = "Remove to run test")]
7878
public void Add_numbers_with_real_and_imaginary_part()
7979
{
8080
var sut = new ComplexNumber(1, 2);
8181
var expected = new ComplexNumber(4, 6);
82-
Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(3, 4)).Real(), 15);
83-
Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(3, 4)).Imaginary(), 15);
82+
Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(3, 4)).Real(), precision: 15);
83+
Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(3, 4)).Imaginary(), precision: 15);
8484
}
8585

8686
[Fact(Skip = "Remove to run test")]
8787
public void Subtract_purely_real_numbers()
8888
{
8989
var sut = new ComplexNumber(1, 0);
9090
var expected = new ComplexNumber(-1, 0);
91-
Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(2, 0)).Real(), 15);
92-
Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(2, 0)).Imaginary(), 15);
91+
Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(2, 0)).Real(), precision: 15);
92+
Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(2, 0)).Imaginary(), precision: 15);
9393
}
9494

9595
[Fact(Skip = "Remove to run test")]
9696
public void Subtract_purely_imaginary_numbers()
9797
{
9898
var sut = new ComplexNumber(0, 1);
9999
var expected = new ComplexNumber(0, -1);
100-
Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(0, 2)).Real(), 15);
101-
Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(0, 2)).Imaginary(), 15);
100+
Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(0, 2)).Real(), precision: 15);
101+
Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(0, 2)).Imaginary(), precision: 15);
102102
}
103103

104104
[Fact(Skip = "Remove to run test")]
105105
public void Subtract_numbers_with_real_and_imaginary_part()
106106
{
107107
var sut = new ComplexNumber(1, 2);
108108
var expected = new ComplexNumber(-2, -2);
109-
Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(3, 4)).Real(), 15);
110-
Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(3, 4)).Imaginary(), 15);
109+
Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(3, 4)).Real(), precision: 15);
110+
Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(3, 4)).Imaginary(), precision: 15);
111111
}
112112

113113
[Fact(Skip = "Remove to run test")]
114114
public void Multiply_purely_real_numbers()
115115
{
116116
var sut = new ComplexNumber(1, 0);
117117
var expected = new ComplexNumber(2, 0);
118-
Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(2, 0)).Real(), 15);
119-
Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(2, 0)).Imaginary(), 15);
118+
Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(2, 0)).Real(), precision: 15);
119+
Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(2, 0)).Imaginary(), precision: 15);
120120
}
121121

122122
[Fact(Skip = "Remove to run test")]
123123
public void Multiply_purely_imaginary_numbers()
124124
{
125125
var sut = new ComplexNumber(0, 1);
126126
var expected = new ComplexNumber(-2, 0);
127-
Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 2)).Real(), 15);
128-
Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 2)).Imaginary(), 15);
127+
Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 2)).Real(), precision: 15);
128+
Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 2)).Imaginary(), precision: 15);
129129
}
130130

131131
[Fact(Skip = "Remove to run test")]
132132
public void Multiply_numbers_with_real_and_imaginary_part()
133133
{
134134
var sut = new ComplexNumber(1, 2);
135135
var expected = new ComplexNumber(-5, 10);
136-
Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(3, 4)).Real(), 15);
137-
Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(3, 4)).Imaginary(), 15);
136+
Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(3, 4)).Real(), precision: 15);
137+
Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(3, 4)).Imaginary(), precision: 15);
138138
}
139139

140140
[Fact(Skip = "Remove to run test")]
141141
public void Divide_purely_real_numbers()
142142
{
143143
var sut = new ComplexNumber(1, 0);
144144
var expected = new ComplexNumber(0.5, 0);
145-
Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(2, 0)).Real(), 15);
146-
Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(2, 0)).Imaginary(), 15);
145+
Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(2, 0)).Real(), precision: 15);
146+
Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(2, 0)).Imaginary(), precision: 15);
147147
}
148148

149149
[Fact(Skip = "Remove to run test")]
150150
public void Divide_purely_imaginary_numbers()
151151
{
152152
var sut = new ComplexNumber(0, 1);
153153
var expected = new ComplexNumber(0.5, 0);
154-
Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(0, 2)).Real(), 15);
155-
Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(0, 2)).Imaginary(), 15);
154+
Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(0, 2)).Real(), precision: 15);
155+
Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(0, 2)).Imaginary(), precision: 15);
156156
}
157157

158158
[Fact(Skip = "Remove to run test")]
159159
public void Divide_numbers_with_real_and_imaginary_part()
160160
{
161161
var sut = new ComplexNumber(1, 2);
162162
var expected = new ComplexNumber(0.44, 0.08);
163-
Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(3, 4)).Real(), 15);
164-
Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(3, 4)).Imaginary(), 15);
163+
Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(3, 4)).Real(), precision: 15);
164+
Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(3, 4)).Imaginary(), precision: 15);
165165
}
166166

167167
[Fact(Skip = "Remove to run test")]
@@ -204,52 +204,52 @@ public void Conjugate_a_purely_real_number()
204204
{
205205
var sut = new ComplexNumber(5, 0);
206206
var expected = new ComplexNumber(5, 0);
207-
Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
208-
Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
207+
Assert.Equal(expected.Real(), sut.Conjugate().Real(), precision: 15);
208+
Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), precision: 15);
209209
}
210210

211211
[Fact(Skip = "Remove to run test")]
212212
public void Conjugate_a_purely_imaginary_number()
213213
{
214214
var sut = new ComplexNumber(0, 5);
215215
var expected = new ComplexNumber(0, -5);
216-
Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
217-
Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
216+
Assert.Equal(expected.Real(), sut.Conjugate().Real(), precision: 15);
217+
Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), precision: 15);
218218
}
219219

220220
[Fact(Skip = "Remove to run test")]
221221
public void Conjugate_a_number_with_real_and_imaginary_part()
222222
{
223223
var sut = new ComplexNumber(1, 1);
224224
var expected = new ComplexNumber(1, -1);
225-
Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
226-
Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
225+
Assert.Equal(expected.Real(), sut.Conjugate().Real(), precision: 15);
226+
Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), precision: 15);
227227
}
228228

229229
[Fact(Skip = "Remove to run test")]
230230
public void Eulers_identity_formula()
231231
{
232232
var sut = new ComplexNumber(0, Math.PI);
233233
var expected = new ComplexNumber(-1, 0);
234-
Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
235-
Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
234+
Assert.Equal(expected.Real(), sut.Exp().Real(), precision: 15);
235+
Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), precision: 15);
236236
}
237237

238238
[Fact(Skip = "Remove to run test")]
239239
public void Exponential_of_0()
240240
{
241241
var sut = new ComplexNumber(0, 0);
242242
var expected = new ComplexNumber(1, 0);
243-
Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
244-
Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
243+
Assert.Equal(expected.Real(), sut.Exp().Real(), precision: 15);
244+
Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), precision: 15);
245245
}
246246

247247
[Fact(Skip = "Remove to run test")]
248248
public void Exponential_of_a_purely_real_number()
249249
{
250250
var sut = new ComplexNumber(1, 0);
251251
var expected = new ComplexNumber(Math.E, 0);
252-
Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
253-
Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
252+
Assert.Equal(expected.Real(), sut.Exp().Real(), precision: 15);
253+
Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), precision: 15);
254254
}
255255
}

‎generators/Exercises/AllYourBase.cs‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -9,8 +9,6 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
99
{
1010
foreach (var canonicalDataCase in canonicalData.Cases)
1111
{
12-
canonicalDataCase.Input["input_digits"] = canonicalDataCase.Input["input_digits"].ConvertToEnumerable<int>();
13-
1412
canonicalDataCase.ExceptionThrown = canonicalDataCase.Expected is null ? typeof(ArgumentException) : null;
1513
canonicalDataCase.UseVariablesForInput = true;
1614
canonicalDataCase.UseVariableForExpected = true;

‎generators/Exercises/Allergies.cs‎

Lines changed: 5 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,5 @@
1-
using System.Collections.Generic;
2-
using System.Linq;
3-
using Generators.Input;
1+
using Generators.Input;
42
using Generators.Output;
5-
using Newtonsoft.Json.Linq;
63

74
namespace Generators.Exercises
85
{
@@ -13,19 +10,11 @@ protected override void UpdateCanonicalData(CanonicalData canonicalData)
1310
foreach (var canonicalDataCase in canonicalData.Cases)
1411
{
1512
if (canonicalDataCase.Property == "allergicTo")
16-
{
1713
canonicalDataCase.Property = "IsAllergicTo";
18-
}
1914
else if (canonicalDataCase.Property == "list")
20-
{
21-
canonicalDataCase.Expected = canonicalDataCase.Expected.ConvertToEnumerable<string>();
2215
canonicalDataCase.UseVariableForExpected = true;
23-
}
2416

25-
canonicalDataCase.ConstructorInput = new Dictionary<string, object>
26-
{
27-
["score"] = canonicalDataCase.Properties["score"]
28-
};
17+
canonicalDataCase.SetConstructorInputParameters("score");
2918
}
3019
}
3120

@@ -41,17 +30,10 @@ private static string RenderIsAllergicToAssert(TestMethodBody testMethodBody)
4130
{
4231
const string template =
4332
@"{%- for allergy in Allergies -%}
44-
Assert.{% if allergy.Result %}True{% else %}False{% endif %}(sut.IsAllergicTo(""{{ allergy.Substance }}""));
33+
Assert.{% if allergy.result %}True{% else %}False{% endif %}(sut.IsAllergicTo(""{{ allergy.substance }}""));
4534
{%- endfor -%}";
46-
47-
var templateParameters = new
48-
{
49-
Allergies = ((JArray) testMethodBody.CanonicalDataCase.Expected)
50-
.Children<JObject>()
51-
.Select(x => new {Result = x["result"].Value<bool>(), Substance = x["substance"].Value<string>()})
52-
.ToArray()
53-
};
54-
35+
36+
var templateParameters = new { Allergies = testMethodBody.CanonicalDataCase.Expected };
5537
return TemplateRenderer.RenderInline(template, templateParameters);
5638
}
5739
}

0 commit comments

Comments
 (0)