Skip to content

Commit 4d86ad2

Browse files
ErikSchierboomErikSchierboom
committed
variable-length-quantity: add generator
1 parent a691db1 commit 4d86ad2

File tree

3 files changed

+103
-103
lines changed

3 files changed

+103
-103
lines changed

‎exercises/practice/variable-length-quantity/.meta/Generator.tpl‎

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
using System;
2+
using Xunit;
3+
4+
public class VariableLengthQuantityTests
5+
{
6+
{{for testCase in testCases}}
7+
[Fact{{if !for.first}}(Skip = "Remove this Skip property to run this test"){{end}}]
8+
public void {{testCase.testMethodName}}()
9+
{
10+
uint[] integers = [
11+
{{for integer in testCase.input.integers}}
12+
{{integer}}{{if !for.last}},{{end}}
13+
{{end}}
14+
];
15+
{{if testCase.expected.error}}
16+
Assert.Throws<InvalidOperationException>(() => VariableLengthQuantity.{{testCase.property | string.capitalize}}(integers));
17+
{{else}}
18+
uint[] expected = [
19+
{{for expected in testCase.expected}}
20+
{{expected}}{{if !for.last}},{{end}}
21+
{{end}}
22+
];
23+
Assert.Equal(expected, VariableLengthQuantity.{{testCase.property | string.capitalize}}(integers));
24+
{{end}}
25+
}
26+
{{end}}
27+
}

‎exercises/practice/variable-length-quantity/VariableLengthQuantityTests.cs‎

Lines changed: 76 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -4,208 +4,208 @@
44
public class VariableLengthQuantityTests
55
{
66
[Fact]
7-
public void Zero()
7+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_zero()
88
{
9-
var integers = new[] { 0x0u };
10-
var expected = new[] { 0x0u };
9+
uint[] integers = [0];
10+
uint[] expected = [0];
1111
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
1212
}
1313

1414
[Fact(Skip = "Remove this Skip property to run this test")]
15-
public void Arbitrary_single_byte()
15+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_single_byte()
1616
{
17-
var integers = new[] { 0x40u };
18-
var expected = new[] { 0x40u };
17+
uint[] integers = [64];
18+
uint[] expected = [64];
1919
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
2020
}
2121

2222
[Fact(Skip = "Remove this Skip property to run this test")]
23-
public void Largest_single_byte()
23+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_largest_single_byte()
2424
{
25-
var integers = new[] { 0x7Fu };
26-
var expected = new[] { 0x7Fu };
25+
uint[] integers = [127];
26+
uint[] expected = [127];
2727
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
2828
}
2929

3030
[Fact(Skip = "Remove this Skip property to run this test")]
31-
public void Smallest_double_byte()
31+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_smallest_double_byte()
3232
{
33-
var integers = new[] { 0x80u };
34-
var expected = new[] { 0x81u, 0x0u };
33+
uint[] integers = [128];
34+
uint[] expected = [129, 0];
3535
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
3636
}
3737

3838
[Fact(Skip = "Remove this Skip property to run this test")]
39-
public void Arbitrary_double_byte()
39+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_double_byte()
4040
{
41-
var integers = new[] { 0x2000u };
42-
var expected = new[] { 0xC0u, 0x0u };
41+
uint[] integers = [8192];
42+
uint[] expected = [192, 0];
4343
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
4444
}
4545

4646
[Fact(Skip = "Remove this Skip property to run this test")]
47-
public void Largest_double_byte()
47+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_largest_double_byte()
4848
{
49-
var integers = new[] { 0x3FFFu };
50-
var expected = new[] { 0xFFu, 0x7Fu };
49+
uint[] integers = [16383];
50+
uint[] expected = [255, 127];
5151
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
5252
}
5353

5454
[Fact(Skip = "Remove this Skip property to run this test")]
55-
public void Smallest_triple_byte()
55+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_smallest_triple_byte()
5656
{
57-
var integers = new[] { 0x4000u };
58-
var expected = new[] { 0x81u, 0x80u, 0x0u };
57+
uint[] integers = [16384];
58+
uint[] expected = [129, 128, 0];
5959
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
6060
}
6161

6262
[Fact(Skip = "Remove this Skip property to run this test")]
63-
public void Arbitrary_triple_byte()
63+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_triple_byte()
6464
{
65-
var integers = new[] { 0x100000u };
66-
var expected = new[] { 0xC0u, 0x80u, 0x0u };
65+
uint[] integers = [1048576];
66+
uint[] expected = [192, 128, 0];
6767
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
6868
}
6969

7070
[Fact(Skip = "Remove this Skip property to run this test")]
71-
public void Largest_triple_byte()
71+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_largest_triple_byte()
7272
{
73-
var integers = new[] { 0x1FFFFFu };
74-
var expected = new[] { 0xFFu, 0xFFu, 0x7Fu };
73+
uint[] integers = [2097151];
74+
uint[] expected = [255, 255, 127];
7575
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
7676
}
7777

7878
[Fact(Skip = "Remove this Skip property to run this test")]
79-
public void Smallest_quadruple_byte()
79+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_smallest_quadruple_byte()
8080
{
81-
var integers = new[] { 0x200000u };
82-
var expected = new[] { 0x81u, 0x80u, 0x80u, 0x0u };
81+
uint[] integers = [2097152];
82+
uint[] expected = [129, 128, 128, 0];
8383
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
8484
}
8585

8686
[Fact(Skip = "Remove this Skip property to run this test")]
87-
public void Arbitrary_quadruple_byte()
87+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_quadruple_byte()
8888
{
89-
var integers = new[] { 0x8000000u };
90-
var expected = new[] { 0xC0u, 0x80u, 0x80u, 0x0u };
89+
uint[] integers = [134217728];
90+
uint[] expected = [192, 128, 128, 0];
9191
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
9292
}
9393

9494
[Fact(Skip = "Remove this Skip property to run this test")]
95-
public void Largest_quadruple_byte()
95+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_largest_quadruple_byte()
9696
{
97-
var integers = new[] { 0xFFFFFFFu };
98-
var expected = new[] { 0xFFu, 0xFFu, 0xFFu, 0x7Fu };
97+
uint[] integers = [268435455];
98+
uint[] expected = [255, 255, 255, 127];
9999
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
100100
}
101101

102102
[Fact(Skip = "Remove this Skip property to run this test")]
103-
public void Smallest_quintuple_byte()
103+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_smallest_quintuple_byte()
104104
{
105-
var integers = new[] { 0x10000000u };
106-
var expected = new[] { 0x81u, 0x80u, 0x80u, 0x80u, 0x0u };
105+
uint[] integers = [268435456];
106+
uint[] expected = [129, 128, 128, 128, 0];
107107
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
108108
}
109109

110110
[Fact(Skip = "Remove this Skip property to run this test")]
111-
public void Arbitrary_quintuple_byte()
111+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_arbitrary_quintuple_byte()
112112
{
113-
var integers = new[] { 0xFF000000u };
114-
var expected = new[] { 0x8Fu, 0xF8u, 0x80u, 0x80u, 0x0u };
113+
uint[] integers = [4278190080];
114+
uint[] expected = [143, 248, 128, 128, 0];
115115
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
116116
}
117117

118118
[Fact(Skip = "Remove this Skip property to run this test")]
119-
public void Maximum_32_bit_integer_input()
119+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_maximum_32_bit_integer_input()
120120
{
121-
var integers = new[] { 0xFFFFFFFFu };
122-
var expected = new[] { 0x8Fu, 0xFFu, 0xFFu, 0xFFu, 0x7Fu };
121+
uint[] integers = [4294967295];
122+
uint[] expected = [143, 255, 255, 255, 127];
123123
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
124124
}
125125

126126
[Fact(Skip = "Remove this Skip property to run this test")]
127-
public void Two_single_byte_values()
127+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_two_single_byte_values()
128128
{
129-
var integers = new[] { 0x40u, 0x7Fu };
130-
var expected = new[] { 0x40u, 0x7Fu };
129+
uint[] integers = [64, 127];
130+
uint[] expected = [64, 127];
131131
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
132132
}
133133

134134
[Fact(Skip = "Remove this Skip property to run this test")]
135-
public void Two_multi_byte_values()
135+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_two_multi_byte_values()
136136
{
137-
var integers = new[] { 0x4000u, 0x123456u };
138-
var expected = new[] { 0x81u, 0x80u, 0x0u, 0xC8u, 0xE8u, 0x56u };
137+
uint[] integers = [16384, 1193046];
138+
uint[] expected = [129, 128, 0, 200, 232, 86];
139139
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
140140
}
141141

142142
[Fact(Skip = "Remove this Skip property to run this test")]
143-
public void Many_multi_byte_values()
143+
public void Encode_a_series_of_integers_producing_a_series_of_bytes_many_multi_byte_values()
144144
{
145-
var integers = new[] { 0x2000u, 0x123456u, 0xFFFFFFFu, 0x0u, 0x3FFFu, 0x4000u };
146-
var expected = new[] { 0xC0u, 0x0u, 0xC8u, 0xE8u, 0x56u, 0xFFu, 0xFFu, 0xFFu, 0x7Fu, 0x0u, 0xFFu, 0x7Fu, 0x81u, 0x80u, 0x0u };
145+
uint[] integers = [8192, 1193046, 268435455, 0, 16383, 16384];
146+
uint[] expected = [192, 0, 200, 232, 86, 255, 255, 255, 127, 0, 255, 127, 129, 128, 0];
147147
Assert.Equal(expected, VariableLengthQuantity.Encode(integers));
148148
}
149149

150150
[Fact(Skip = "Remove this Skip property to run this test")]
151-
public void One_byte()
151+
public void Decode_a_series_of_bytes_producing_a_series_of_integers_one_byte()
152152
{
153-
var integers = new[] { 0x7Fu };
154-
var expected = new[] { 0x7Fu };
153+
uint[] integers = [127];
154+
uint[] expected = [127];
155155
Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
156156
}
157157

158158
[Fact(Skip = "Remove this Skip property to run this test")]
159-
public void Two_bytes()
159+
public void Decode_a_series_of_bytes_producing_a_series_of_integers_two_bytes()
160160
{
161-
var integers = new[] { 0xC0u, 0x0u };
162-
var expected = new[] { 0x2000u };
161+
uint[] integers = [192, 0];
162+
uint[] expected = [8192];
163163
Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
164164
}
165165

166166
[Fact(Skip = "Remove this Skip property to run this test")]
167-
public void Three_bytes()
167+
public void Decode_a_series_of_bytes_producing_a_series_of_integers_three_bytes()
168168
{
169-
var integers = new[] { 0xFFu, 0xFFu, 0x7Fu };
170-
var expected = new[] { 0x1FFFFFu };
169+
uint[] integers = [255, 255, 127];
170+
uint[] expected = [2097151];
171171
Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
172172
}
173173

174174
[Fact(Skip = "Remove this Skip property to run this test")]
175-
public void Four_bytes()
175+
public void Decode_a_series_of_bytes_producing_a_series_of_integers_four_bytes()
176176
{
177-
var integers = new[] { 0x81u, 0x80u, 0x80u, 0x0u };
178-
var expected = new[] { 0x200000u };
177+
uint[] integers = [129, 128, 128, 0];
178+
uint[] expected = [2097152];
179179
Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
180180
}
181181

182182
[Fact(Skip = "Remove this Skip property to run this test")]
183-
public void Maximum_32_bit_integer()
183+
public void Decode_a_series_of_bytes_producing_a_series_of_integers_maximum_32_bit_integer()
184184
{
185-
var integers = new[] { 0x8Fu, 0xFFu, 0xFFu, 0xFFu, 0x7Fu };
186-
var expected = new[] { 0xFFFFFFFFu };
185+
uint[] integers = [143, 255, 255, 255, 127];
186+
uint[] expected = [4294967295];
187187
Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
188188
}
189189

190190
[Fact(Skip = "Remove this Skip property to run this test")]
191-
public void Incomplete_sequence_causes_error()
191+
public void Decode_a_series_of_bytes_producing_a_series_of_integers_incomplete_sequence_causes_error()
192192
{
193-
var integers = new[] { 0xFFu };
193+
uint[] integers = [255];
194194
Assert.Throws<InvalidOperationException>(() => VariableLengthQuantity.Decode(integers));
195195
}
196196

197197
[Fact(Skip = "Remove this Skip property to run this test")]
198-
public void Incomplete_sequence_causes_error_even_if_value_is_zero()
198+
public void Decode_a_series_of_bytes_producing_a_series_of_integers_incomplete_sequence_causes_error_even_if_value_is_zero()
199199
{
200-
var integers = new[] { 0x80u };
200+
uint[] integers = [128];
201201
Assert.Throws<InvalidOperationException>(() => VariableLengthQuantity.Decode(integers));
202202
}
203203

204204
[Fact(Skip = "Remove this Skip property to run this test")]
205-
public void Multiple_values()
205+
public void Decode_a_series_of_bytes_producing_a_series_of_integers_multiple_values()
206206
{
207-
var integers = new[] { 0xC0u, 0x0u, 0xC8u, 0xE8u, 0x56u, 0xFFu, 0xFFu, 0xFFu, 0x7Fu, 0x0u, 0xFFu, 0x7Fu, 0x81u, 0x80u, 0x0u };
208-
var expected = new[] { 0x2000u, 0x123456u, 0xFFFFFFFu, 0x0u, 0x3FFFu, 0x4000u };
207+
uint[] integers = [192, 0, 200, 232, 86, 255, 255, 255, 127, 0, 255, 127, 129, 128, 0];
208+
uint[] expected = [8192, 1193046, 268435455, 0, 16383, 16384];
209209
Assert.Equal(expected, VariableLengthQuantity.Decode(integers));
210210
}
211211
}

‎generators.deprecated/Exercises/Generators/VariableLengthQuantity.cs‎

Lines changed: 0 additions & 27 deletions
This file was deleted.

0 commit comments

Comments
 (0)