public void Describe(string exampleGroupName, As examples)
{
var exampleGroup = new ExampleGroup(exampleGroupName, m_letExpressions);
examples(exampleGroup);
m_specComponents.Add(exampleGroup);
}
public static void Main(string[] args)
{
try {
var exampleGroupWithFailure = new ExampleGroup();
exampleGroupWithFailure.Add("A deliberate failing example to prove we can count failing tests",
() => { throw new Exception(); }
);
exampleGroupWithFailure.Run();
if (exampleGroupWithFailure.Status != "1 run, 1 failures")
{
throw new Exception();
}
} catch {
Console.WriteLine("The bootstrap test failed");
throw;
}
var mainExampleGroup = new ExampleGroup("Main ExampleGroup");
ContextFreeExample validExample = () => { };
ContextFreeExample failingExample = () => { throw new Exception(); };
// TODO: Do we need a bootstrap test for Let?
mainExampleGroup.Let("exampleGroup", () => new ExampleGroup("ExampleGroup name"));
mainExampleGroup.Add("An unrun ExampleGroup Status indicates it has not been run",
(dynamic our) => {
Expect.That(our.exampleGroup.Status, Is.EqualTo("Not run"));
}
);
mainExampleGroup.Add("ExampleGroup Status with no Examples",
(dynamic our) => {
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Status, Is.EqualTo("0 run, 0 failures"));
}
);
mainExampleGroup.Add("ExampleGroup Status with one valid Example",
(dynamic our) => {
our.exampleGroup.Add("Valid Example", validExample);
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Status, Is.EqualTo("1 run, 0 failures"));
}
);
mainExampleGroup.Add("ExampleGroup Status with one valid Example and one failing Example",
(dynamic our) => {
our.exampleGroup.Add("Valid Example", validExample);
our.exampleGroup.Add("Invalid Example", failingExample);
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Status, Is.EqualTo("2 run, 1 failures"));
}
);
mainExampleGroup.Add("ExampleGroup ErrorLog includes exception class and message", (dynamic our) => {
our.exampleGroup.Add("Invalid Example", (ContextFreeExample)(() => { throw new ApplicationException("Example failure"); }));
our.exampleGroup.Run();
// This is a weak spec, but the formatting is WIP
Expect.That(our.exampleGroup.ErrorLog.Contains("Invalid Example"));
Expect.That(our.exampleGroup.ErrorLog.Contains("System.ApplicationException"));
Expect.That(our.exampleGroup.ErrorLog.Contains("Example failure"));
});
mainExampleGroup.Add("Expect.That ... Is.EqualTo formats an error", (dynamic our) => {
our.exampleGroup.Add("Invalid Example", (ContextFreeExample)(() => {
Expect.That("foo", Is.EqualTo("bar"));
}));
our.exampleGroup.Run();
Expect.That(our.exampleGroup.ErrorLog.Contains("Invalid Example"));
Expect.That(our.exampleGroup.ErrorLog.Contains("CSharpTestFramework.ExpectationException"));
Expect.That(our.exampleGroup.ErrorLog.Contains("Expected System.String \"foo\" to be equal to System.String \"bar\", but it was not"));
});
mainExampleGroup.Add("Expect.That ... Contains.Value formats an error", (dynamic our) => {
our.exampleGroup.Add("Invalid Example", (ContextFreeExample)(() => {
try {
Expect.That("foo baz", Contains.Value("bar"));
} catch (Exception e) {
throw e;
}
}));
our.exampleGroup.Run();
Expect.That(our.exampleGroup.ErrorLog.Contains("Invalid Example"));
Expect.That(our.exampleGroup.ErrorLog.Contains("CSharpTestFramework.ExpectationException"));
Expect.That(our.exampleGroup.ErrorLog.Contains("Expected System.String \"foo baz\" to contain System.String \"bar\", but it did not"));
});
mainExampleGroup.Add("ExampleGroup ErrorLog",
(dynamic our) => {
our.exampleGroup.Add("Failing Example", (ContextFreeExample)(() => {
throw new Exception("This fails");
}));
our.exampleGroup.Add("Another failing example", (ContextFreeExample)(() => {
throw new Exception("And this fails too");
}));
our.exampleGroup.Run();
Expect.That(our.exampleGroup.ErrorLog.Contains("This fails"));
Expect.That(our.exampleGroup.ErrorLog.Contains("And this fails too"));
}
);
mainExampleGroup.Add("ExampleGroup Report includes the name", (dynamic our) => {
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Report.Contains("Example group: ExampleGroup name"));
});
mainExampleGroup.Add("ExampleGroup Report includes the Example names", (dynamic our) => {
our.exampleGroup.Add("Example name 1", validExample);
our.exampleGroup.Add("Example name 2", validExample);
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Report.Contains("- Example name 1"));
Expect.That(our.exampleGroup.Report.Contains("- Example name 2"));
});
mainExampleGroup.Add("ExampleGroup Report flags failing Examples", (dynamic our) => {
our.exampleGroup.Add("Example name 1", failingExample);
our.exampleGroup.Add("Example name 2", failingExample);
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Report.Contains("X Example name 1"));
Expect.That(our.exampleGroup.Report.Contains("X Example name 2"));
});
mainExampleGroup.Add("ExampleGroup with Let expression and one passing Example", (dynamic our) => {
our.exampleGroup.Let("TestObject", (Be)(() => "value of TestObject"));
our.exampleGroup.Add("Expect the right value", (Example)((dynamic ourInner) => {
Expect.That(ourInner.TestObject == "value of TestObject");
}));
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Status, Is.EqualTo("1 run, 0 failures"));
});
// TODO: Make the Expect fail correctly and improve the framework to prevent this type of error
mainExampleGroup.Add("ExampleGroup with Let expression and one failing Example", (dynamic our) => {
our.exampleGroup.Let("TestObject", (Be)(() => "value of TestObject"));
our.exampleGroup.Add("Expect the wrong value", (Example)((dynamic ourInner) => {
// This is actually failing because we used `our` not `ourInner`
Expect.That(our.TestObject == "wrong value of TestObject");
}));
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Status, Is.EqualTo("1 run, 1 failures"));
});
mainExampleGroup.Add("ExampleGroup with multiple Let expressions", (dynamic our) => {
our.exampleGroup.Let("TestObject1", (Be)(() => 1));
our.exampleGroup.Let("TestObject2", (Be)(() => 2));
our.exampleGroup.Add("Access both Let values", (Example)((dynamic ourInner) => {
Expect.That(ourInner.TestObject1 == 1);
Expect.That(ourInner.TestObject2 == 2);
}));
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Status, Is.EqualTo("1 run, 0 failures"));
});
mainExampleGroup.Add("ExampleGroup only evaluates Let expressions once per Example", (dynamic our) => {
var accesses = new Dictionary <string, int>()
{
{ "TestObject lookups", 0 }
};
our.exampleGroup.Let("TestObject", (Be)(() => accesses["TestObject lookups"] += 1));
our.exampleGroup.Add("Access Let value twice", (Example)((dynamic ourInner) => {
Expect.That(ourInner.TestObject == 1);
Expect.That(ourInner.TestObject == 1);
}));
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Status, Is.EqualTo("1 run, 0 failures"));
});
mainExampleGroup.Add("ExampleGroup re-evaluates Let expressions for each Example", (dynamic our) => {
var accesses = new Dictionary <string, int>()
{
{ "TestObject lookups", 0 }
};
our.exampleGroup.Let("TestObject", (Be)(() => accesses["TestObject lookups"] += 1));
our.exampleGroup.Add("Access first value of Let expression", (Example)((dynamic ourInner) => {
Expect.That(ourInner.TestObject == 1);
}));
our.exampleGroup.Add("Access second value of Let expression", (Example)((dynamic ourInner) => {
Expect.That(ourInner.TestObject == 2);
}));
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Status, Is.EqualTo("2 run, 0 failures"));
});
mainExampleGroup.Add("ExampleGroups can be nested with Describe", (dynamic our) => {
our.exampleGroup.Describe("A description of a nested ExampleGroup", (As)((dynamic ourInner) => {
ourInner.Add("An example", (ContextFreeExample)(() => { }));
ourInner.Describe("A deeply-nested ExampleGroup name", (As)((dynamic ourInner2) => {
ourInner2.Add("Another example", (ContextFreeExample)(() => { }));
}));
}));
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Report, Contains.Value("ExampleGroup name"));
Expect.That(our.exampleGroup.Report, Contains.Value("A description of a nested ExampleGroup"));
Expect.That(our.exampleGroup.Report, Contains.Value("A deeply-nested ExampleGroup name"));
Expect.That(our.exampleGroup.Report, Contains.Value("An example"));
Expect.That(our.exampleGroup.Report, Contains.Value("Another example"));
});
mainExampleGroup.Add("ExampleGroups with nested Describes count all Examples", (dynamic our) => {
our.exampleGroup.Describe("A description of a nested ExampleGroup", (As)((dynamic ourInner) => {
ourInner.Add("An example", (ContextFreeExample)(() => { }));
ourInner.Describe("A deeply-nested ExampleGroup name", (As)((dynamic ourInner2) => {
ourInner2.Add("An example", (ContextFreeExample)(() => { throw new Exception("Fail"); }));
}));
}));
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Status, Is.EqualTo("2 run, 1 failures"));
});
mainExampleGroup.Add("Examples in nested ExampleGroups can use Let expressions from higher up", (dynamic our) => {
our.exampleGroup.Let("TheNumberOne", (Be)(() => 1));
our.exampleGroup.Describe("A description of a nested ExampleGroup", (As)((dynamic ourInner) => {
ourInner.Add("An example", (Example)((dynamic context) => { Expect.That(context.TheNumberOne, Is.EqualTo(1)); }));
ourInner.Describe("A deeply-nested ExampleGroup name", (As)((dynamic ourInner2) => {
ourInner2.Add("An example", (Example)((dynamic context2) => { Expect.That(context2.TheNumberOne, Is.EqualTo(1)); }));
}));
}));
our.exampleGroup.Run();
Expect.That(our.exampleGroup.Status, Is.EqualTo("2 run, 0 failures"));
});
// TODO: ErrorLog from nested Examples is included in nested log
// Expectations
mainExampleGroup.Add("Expect.That ...", () => {
Expect.That(true);
});
mainExampleGroup.Add("Expect.That ... Contains.Value", () => {
Expect.That("foo bar baz", Contains.Value("bar"));
});
mainExampleGroup.Run();
Console.WriteLine(mainExampleGroup.Report);
Console.WriteLine(mainExampleGroup.ErrorLog);
Console.WriteLine(mainExampleGroup.Status);
}