Skip to content

Commit 6909042

Browse files
izrikizrik
authored
Merge pull request #18 from metaindu/clean-up-tests
Clean up tests
2 parents bea35e2 + 2312c99 commit 6909042

27 files changed

+1589
-1307
lines changed

‎MetaphysicsIndustries.Giza.Test/CSharpPathTest.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -72,7 +72,7 @@ public void PosixCombineAbsoluteAndRelative()
7272
var a2 = Path.Combine(a1, toPath);
7373
var a3 = Path.GetFullPath(a2);
7474
// then
75-
Assert.AreEqual("/path/to/another/file2.giza", a3);
75+
Assert.That(a3, Is.EqualTo("/path/to/another/file2.giza"));
7676
}
7777
}
7878
}

‎MetaphysicsIndustries.Giza.Test/CharacterSourceTest.cs‎

Lines changed: 120 additions & 114 deletions
Large diffs are not rendered by default.

‎MetaphysicsIndustries.Giza.Test/CommandLineTest.cs‎

Lines changed: 17 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -60,15 +60,16 @@ public void TestCommandLine2()
6060
giza.Program.Main(new string[] { "check", "--tokenized", "-" });
6161

6262
// assertions
63-
Assert.AreEqual("", newStderr.ToString());
64-
Assert.AreEqual(
65-
"There are 5 definitions in the grammar:\n" +
66-
" expr\n" +
67-
" value\n" +
68-
" number\n" +
69-
" varref\n" +
70-
" $implicit char class *+-/\n",
71-
newStdout.ToString());
63+
Assert.That(newStderr.ToString(), Is.EqualTo(""));
64+
Assert.That(
65+
newStdout.ToString(),
66+
Is.EqualTo(
67+
"There are 5 definitions in the grammar:\n" +
68+
" expr\n" +
69+
" value\n" +
70+
" number\n" +
71+
" varref\n" +
72+
" $implicit char class *+-/\n"));
7273
}
7374

7475
class MultipleStdIn : TextReader
@@ -169,10 +170,10 @@ public void TestCommandLineParse()
169170
giza.Program.Main(new string[] { "parse", "-", "expr", "-" });
170171

171172
// assertions
172-
Assert.AreEqual("", newStderr.ToString());
173-
Assert.AreEqual(
174-
"There is 1 valid parse of the input.\n",
175-
newStdout.ToString());
173+
Assert.That(newStderr.ToString(), Is.EqualTo(""));
174+
Assert.That(
175+
newStdout.ToString(),
176+
Is.EqualTo("There is 1 valid parse of the input.\n"));
176177
}
177178

178179
[Test]
@@ -199,10 +200,9 @@ public void TestCommandLineSpan()
199200
giza.Program.Main(new string[] { "span", "-", "expr", "-" });
200201

201202
// assertions
202-
Assert.AreEqual("", newStderr.ToString());
203-
Assert.AreEqual(
204-
"There is 1 valid span of the input.\n",
205-
newStdout.ToString());
203+
Assert.That(newStderr.ToString(), Is.EqualTo(""));
204+
Assert.That(newStdout.ToString(),
205+
Is.EqualTo("There is 1 valid span of the input.\n"));
206206
}
207207
}
208208
}

‎MetaphysicsIndustries.Giza.Test/DefinitionCheckerTest.cs‎

Lines changed: 32 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -165,11 +165,12 @@ public void TestNoPathFromStart()
165165

166166
// assertions
167167
Assert.IsNotNull(errorEnu);
168-
Assert.AreEqual(1, errors.Count);
168+
Assert.That(errors.Count, Is.EqualTo(1));
169169
Assert.IsInstanceOf<DefinitionError>(errors[0]);
170170
var err = (DefinitionError)errors[0];
171-
Assert.AreEqual(DefinitionError.NodeHasNoPathFromStart, err.ErrorType);
172-
Assert.AreSame(n2, err.Node);
171+
Assert.That(err.ErrorType,
172+
Is.EqualTo(DefinitionError.NodeHasNoPathFromStart));
173+
Assert.That(err.Node, Is.SameAs(n2));
173174
}
174175

175176
[Test]
@@ -201,11 +202,12 @@ public void TestNoPathToEnd()
201202

202203
// assertions
203204
Assert.IsNotNull(errorEnu);
204-
Assert.AreEqual(1, errors.Count);
205+
Assert.That(errors.Count, Is.EqualTo(1));
205206
Assert.IsInstanceOf<DefinitionError>(errors[0]);
206207
var err = (DefinitionError)errors[0];
207-
Assert.AreEqual(DefinitionError.NodeHasNoPathToEnd, err.ErrorType);
208-
Assert.AreSame(n2, err.Node);
208+
Assert.That(err.ErrorType,
209+
Is.EqualTo(DefinitionError.NodeHasNoPathToEnd));
210+
Assert.That(err.Node, Is.SameAs(n2));
209211
}
210212

211213
[Test]
@@ -233,11 +235,12 @@ public void TestNextNodeOutsideDefinition1()
233235

234236
// assertions
235237
Assert.IsNotNull(errorEnu);
236-
Assert.AreEqual(1, errors.Count);
238+
Assert.That(errors.Count, Is.EqualTo(1));
237239
Assert.IsInstanceOf<DefinitionError>(errors[0]);
238240
var err = (DefinitionError)errors[0];
239-
Assert.AreEqual(DefinitionError.NextNodeLinksOutsideOfDefinition, err.ErrorType);
240-
Assert.AreSame(n1, err.Node);
241+
Assert.That(err.ErrorType,
242+
Is.EqualTo(DefinitionError.NextNodeLinksOutsideOfDefinition));
243+
Assert.That(err.Node, Is.SameAs(n1));
241244
}
242245

243246
[Test]
@@ -261,11 +264,12 @@ public void TestNextNodeOutsideDefinition2()
261264

262265
// assertions
263266
Assert.IsNotNull(errorEnu);
264-
Assert.AreEqual(1, errors.Count);
267+
Assert.That(errors.Count, Is.EqualTo(1));
265268
Assert.IsInstanceOf<DefinitionError>(errors[0]);
266269
var err = (DefinitionError)errors[0];
267-
Assert.AreEqual(DefinitionError.NextNodeLinksOutsideOfDefinition, err.ErrorType);
268-
Assert.AreSame(n1, err.Node);
270+
Assert.That(err.ErrorType,
271+
Is.EqualTo(DefinitionError.NextNodeLinksOutsideOfDefinition));
272+
Assert.That(err.Node, Is.SameAs(n1));
269273
}
270274

271275
[Test]
@@ -294,11 +298,12 @@ public void TestStartNodeHasWrongParentDefinition1()
294298

295299
// assertions
296300
Assert.IsNotNull(errorEnu);
297-
Assert.AreEqual(1, errors.Count);
301+
Assert.That(errors.Count, Is.EqualTo(1));
298302
Assert.IsInstanceOf<DefinitionError>(errors[0]);
299303
var err = (DefinitionError)errors[0];
300-
Assert.AreEqual(DefinitionError.StartNodeHasWrongParentDefinition, err.ErrorType);
301-
Assert.AreSame(n2, err.Node);
304+
Assert.That(err.ErrorType,
305+
Is.EqualTo(DefinitionError.StartNodeHasWrongParentDefinition));
306+
Assert.That(err.Node, Is.SameAs(n2));
302307
}
303308

304309
[Test]
@@ -323,11 +328,12 @@ public void TestStartNodeHasWrongParentDefinition2()
323328

324329
// assertions
325330
Assert.IsNotNull(errorEnu);
326-
Assert.AreEqual(1, errors.Count);
331+
Assert.That(errors.Count, Is.EqualTo(1));
327332
Assert.IsInstanceOf<DefinitionError>(errors[0]);
328333
var err = (DefinitionError)errors[0];
329-
Assert.AreEqual(DefinitionError.StartNodeHasWrongParentDefinition, err.ErrorType);
330-
Assert.AreSame(n2, err.Node);
334+
Assert.That(err.ErrorType,
335+
Is.EqualTo(DefinitionError.StartNodeHasWrongParentDefinition));
336+
Assert.That(err.Node, Is.SameAs(n2));
331337
}
332338

333339
[Test]
@@ -356,11 +362,12 @@ public void TestEndNodeHasWrongParentDefinition1()
356362

357363
// assertions
358364
Assert.IsNotNull(errorEnu);
359-
Assert.AreEqual(1, errors.Count);
365+
Assert.That(errors.Count, Is.EqualTo(1));
360366
Assert.IsInstanceOf<DefinitionError>(errors[0]);
361367
var err = (DefinitionError)errors[0];
362-
Assert.AreEqual(DefinitionError.EndNodeHasWrongParentDefinition, err.ErrorType);
363-
Assert.AreSame(n2, err.Node);
368+
Assert.That(err.ErrorType,
369+
Is.EqualTo(DefinitionError.EndNodeHasWrongParentDefinition));
370+
Assert.That(err.Node, Is.SameAs(n2));
364371
}
365372

366373
[Test]
@@ -385,11 +392,12 @@ public void TestEndNodeHasWrongParentDefinition2()
385392

386393
// assertions
387394
Assert.IsNotNull(errorEnu);
388-
Assert.AreEqual(1, errors.Count);
395+
Assert.That(errors.Count, Is.EqualTo(1));
389396
Assert.IsInstanceOf<DefinitionError>(errors[0]);
390397
var err = (DefinitionError)errors[0];
391-
Assert.AreEqual(DefinitionError.EndNodeHasWrongParentDefinition, err.ErrorType);
392-
Assert.AreSame(n2, err.Node);
398+
Assert.That(err.ErrorType,
399+
Is.EqualTo(DefinitionError.EndNodeHasWrongParentDefinition));
400+
Assert.That(err.Node, Is.SameAs(n2));
393401
}
394402

395403
[Test]

‎MetaphysicsIndustries.Giza.Test/DefinitionRendererTest.cs‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -45,7 +45,7 @@ public void TestRenderDefinitionExprsAsGrammarText()
4545
var dr = new DefinitionRenderer();
4646
var result = dr.RenderDefinitionExprsAsGrammarText(g.Definitions);
4747

48-
Assert.AreEqual(input, result);
48+
Assert.That(result, Is.EqualTo(input));
4949
}
5050

5151
[Test]
@@ -63,7 +63,7 @@ public void TestRenderDefinitionExprsAsGrammarTextModifiers()
6363
var dr = new DefinitionRenderer();
6464
var result = dr.RenderDefinitionExprsAsGrammarText(g.Definitions);
6565

66-
Assert.AreEqual(input, result);
66+
Assert.That(result, Is.EqualTo(input));
6767
}
6868

6969
[Test]
@@ -82,7 +82,7 @@ public void TestRenderDefinitionExprsAsGrammarTextTags()
8282
var dr = new DefinitionRenderer();
8383
var result = dr.RenderDefinitionExprsAsGrammarText(g.Definitions);
8484

85-
Assert.AreEqual(input, result);
85+
Assert.That(result, Is.EqualTo(input));
8686
}
8787

8888
[Test]
@@ -105,7 +105,7 @@ public void TestRenderDefinitionExprsAsGrammarTextDirectives()
105105
var dr = new DefinitionRenderer();
106106
var result = dr.RenderDefinitionExprsAsGrammarText(g.Definitions);
107107

108-
Assert.AreEqual(input, result);
108+
Assert.That(result, Is.EqualTo(input));
109109
}
110110

111111
// TODO: test C# output

‎MetaphysicsIndustries.Giza.Test/DefinitionTest.cs‎

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -31,7 +31,7 @@ public void CreateYieldsNewObjectWithDefaultValues()
3131
var result = new Definition();
3232
// then
3333
Assert.IsNotNull(result);
34-
Assert.AreEqual("", result.Name);
34+
Assert.That(result.Name, Is.EqualTo(""));
3535
Assert.IsEmpty(result.Directives);
3636
Assert.IsNotNull(result.Expr);
3737
Assert.IsEmpty(result.Expr.Items);
@@ -53,16 +53,16 @@ public void CreateWithParametersYieldsThoseValues()
5353
"source1");
5454
// then
5555
Assert.IsNotNull(result);
56-
Assert.AreEqual("def1", result.Name);
56+
Assert.That(result.Name, Is.EqualTo("def1"));
5757
Assert.IsNotEmpty(result.Directives);
5858
Assert.IsTrue(
5959
result.Directives.Contains(DefinitionDirective.Atomic));
6060
Assert.IsTrue(
6161
result.Directives.Contains(DefinitionDirective.IgnoreCase));
6262
Assert.IsNotNull(result.Expr);
63-
Assert.AreSame(expr, result.Expr);
63+
Assert.That(result.Expr, Is.SameAs(expr));
6464
Assert.IsTrue(result.IsImported);
65-
Assert.AreEqual("source1", result.Source);
65+
Assert.That(result.Source, Is.EqualTo("source1"));
6666
}
6767

6868
[Test]
@@ -80,14 +80,14 @@ public void CloneWithNoArgsYieldsCopy()
8080
var result = def.Clone();
8181
// then
8282
Assert.IsNotNull(result);
83-
Assert.AreEqual("def1", result.Name);
83+
Assert.That(result.Name, Is.EqualTo("def1"));
8484
Assert.IsNotEmpty(result.Directives);
8585
Assert.IsTrue(
8686
result.Directives.Contains(DefinitionDirective.Atomic));
8787
Assert.IsTrue(
8888
result.Directives.Contains(DefinitionDirective.IgnoreCase));
8989
Assert.IsNotNull(result.Expr);
90-
Assert.AreSame(expr, result.Expr);
90+
Assert.That(result.Expr, Is.SameAs(expr));
9191
Assert.IsTrue(result.IsImported);
9292
}
9393

@@ -106,14 +106,14 @@ public void CloneWithNewNameYieldsCopyWithThatValue()
106106
var result = def.Clone(newName: "def2");
107107
// then
108108
Assert.IsNotNull(result);
109-
Assert.AreEqual("def2", result.Name);
109+
Assert.That(result.Name, Is.EqualTo("def2"));
110110
Assert.IsNotEmpty(result.Directives);
111111
Assert.IsTrue(
112112
result.Directives.Contains(DefinitionDirective.Atomic));
113113
Assert.IsTrue(
114114
result.Directives.Contains(DefinitionDirective.IgnoreCase));
115115
Assert.IsNotNull(result.Expr);
116-
Assert.AreSame(expr, result.Expr);
116+
Assert.That(result.Expr, Is.SameAs(expr));
117117
Assert.IsTrue(result.IsImported);
118118
}
119119

@@ -133,7 +133,7 @@ public void CloneWithNewDirectiveYieldsCopyWithThatValue()
133133
newDirectives: new []{DefinitionDirective.MindWhitespace});
134134
// then
135135
Assert.IsNotNull(result);
136-
Assert.AreEqual("def1", result.Name);
136+
Assert.That(result.Name, Is.EqualTo("def1"));
137137
Assert.IsNotEmpty(result.Directives);
138138
Assert.IsFalse(
139139
result.Directives.Contains(DefinitionDirective.Atomic));
@@ -143,7 +143,7 @@ public void CloneWithNewDirectiveYieldsCopyWithThatValue()
143143
result.Directives.Contains(
144144
DefinitionDirective.MindWhitespace));
145145
Assert.IsNotNull(result.Expr);
146-
Assert.AreSame(expr, result.Expr);
146+
Assert.That(result.Expr, Is.SameAs(expr));
147147
Assert.IsTrue(result.IsImported);
148148
}
149149

@@ -164,15 +164,15 @@ public void CloneWithNewExprYieldsCopyWithThatValue()
164164
var result = def.Clone(newExpr: expr2);
165165
// then
166166
Assert.IsNotNull(result);
167-
Assert.AreEqual("def1", result.Name);
167+
Assert.That(result.Name, Is.EqualTo("def1"));
168168
Assert.IsNotEmpty(result.Directives);
169169
Assert.IsTrue(
170170
result.Directives.Contains(DefinitionDirective.Atomic));
171171
Assert.IsTrue(
172172
result.Directives.Contains(DefinitionDirective.IgnoreCase));
173173
Assert.IsNotNull(result.Expr);
174-
Assert.AreNotSame(expr1, result.Expr);
175-
Assert.AreSame(expr2, result.Expr);
174+
Assert.That(result.Expr, Is.Not.SameAs(expr1));
175+
Assert.That(result.Expr, Is.SameAs(expr2));
176176
Assert.IsTrue(result.IsImported);
177177
}
178178

@@ -191,14 +191,14 @@ public void CloneWithNewIsImportedYieldsCopyWithThatValue()
191191
var result = def.Clone(newIsImported: false);
192192
// then
193193
Assert.IsNotNull(result);
194-
Assert.AreEqual("def1", result.Name);
194+
Assert.That(result.Name, Is.EqualTo("def1"));
195195
Assert.IsNotEmpty(result.Directives);
196196
Assert.IsTrue(
197197
result.Directives.Contains(DefinitionDirective.Atomic));
198198
Assert.IsTrue(
199199
result.Directives.Contains(DefinitionDirective.IgnoreCase));
200200
Assert.IsNotNull(result.Expr);
201-
Assert.AreSame(expr, result.Expr);
201+
Assert.That(result.Expr, Is.SameAs(expr));
202202
Assert.IsFalse(result.IsImported);
203203
}
204204

@@ -217,14 +217,14 @@ public void CloneWithNewIsImportedYieldsCopyWithThatValue2()
217217
var result = def.Clone(newIsImported: true);
218218
// then
219219
Assert.IsNotNull(result);
220-
Assert.AreEqual("def1", result.Name);
220+
Assert.That(result.Name, Is.EqualTo("def1"));
221221
Assert.IsNotEmpty(result.Directives);
222222
Assert.IsTrue(
223223
result.Directives.Contains(DefinitionDirective.Atomic));
224224
Assert.IsTrue(
225225
result.Directives.Contains(DefinitionDirective.IgnoreCase));
226226
Assert.IsNotNull(result.Expr);
227-
Assert.AreSame(expr, result.Expr);
227+
Assert.That(result.Expr, Is.SameAs(expr));
228228
Assert.IsTrue(result.IsImported);
229229
}
230230

@@ -236,7 +236,7 @@ public void ToStringIncludesName()
236236
// when
237237
var result = def.ToString();
238238
// then
239-
Assert.AreEqual("Definition def1", result);
239+
Assert.That(result, Is.EqualTo("Definition def1"));
240240
}
241241
}
242242
}

0 commit comments

Comments
 (0)