Shouldly

How asserting Should be

This is the old Assert way:

Assert.That(contestant.Points, Is.EqualTo(1337));

For your troubles, you get this message, when it fails:

Expected 1337 but was 0

How it Should be:

contestant.Points.ShouldBe(1337);

Which is just syntax, so far, but check out the message when it fails:

contestant.Points should be 1337 but was 0

It might be easy to underestimate how useful this is. Another example, side by side:

Assert.That(map.IndexOfValue("boo"), Is.EqualTo(2));    // -> Expected 2 but was 1
map.IndexOfValue("boo").ShouldBe(2);                    // -> map.IndexOfValue("boo") should be 2 but was 1

Shouldly uses the variables within the ShouldBe statement to report on errors, which makes diagnosing easier.

Another example, if you compare two collections:

(new[] { 1, 2, 3 }).ShouldBe(new[] { 1, 2, 4 });

and it fails because they're different, it'll show you the differences between the two collections:

    should be
[1, 2, 4]
    but was
[1, 2, 3]
    difference
[1, 2, *3*]

If you want to check that a particular call does/does not throw an exception, it's as simple as:

Should.Throw<ArgumentOutOfRangeException>(() => widget.Twist(-1));

Then if it chucks a wobbly, you have access to the exception to help debug what the underlying cause was.

Other Shouldly features:

####Equality

[ShouldBe] (#equalityShouldBeExample)

[ShouldBeOneOf] (#equalityShouldBeOneOfExample)

[ShouldNotBe] (#equalityShouldNotBeExample)

[ShouldNotBeOneOf] (#equalityShouldNotBeOneOfExample)

[ShouldBeGreaterThan(OrEqualTo)] (#equalityShouldBeGreaterThanExample)

[ShouldBeLessThan(OrEqualTo)] (#equalityShouldBeLessThanExample)

[ShouldBeOfType - Exact type match] (#equalityShouldBeOfTypeExample)

[ShouldBeAssignableTo] (#equalityShouldBeAssignableToExample)

[ShouldBeInRange] (#equalityShouldBeInRangeExample)

[ShouldNotBeInRange] (#equalityShouldNotBeInRangeExample)

####Enumerable

[ShouldBe(optional Tolerance/Ignore order)] (#enumerableShouldBeExample)

[ShouldAllBe(predicate)] (#enumerableShouldAllBeExample)

[ShouldContain] (#enumerableShouldContainExample)

[ShouldContain(predicate)] (#enumerableShouldContainExample)

[ShouldNotContain] (#enumerableShouldNotContainExample)

[ShouldNotContain(predicate)] (#enumerableShouldNotContainExample)

[ShouldBeEmpty] (#enumerableShouldBeEmptyExample)

[ShouldNotBeEmpty] (#enumerableShouldNotBeEmptyExample)

[ShouldBeOneOf(params)] (#enumerableShouldBeOneOfExample)

[ShouldBeSubsetOf] (#enumerableShouldBeSubsetOfExample)

####String

[ShouldStartWith] (#stringShouldStartWithExample)

[ShouldNotStartWith] (#stringShouldNotStartWithExample)

[ShouldEndWith] (#stringShouldEndWithExample)

[ShouldNotEndWith] (#stringShouldNotEndWithExample)

[ShouldContain] (#stringShouldContainExample)

[ShouldNotContain] (#stringShouldNotContainExample)

[ShouldContainWithoutWhitespace] (#stringShouldContainWithoutWhitespaceExample)

[ShouldMatch] (#stringShouldMatchExample)

[ShouldBeNullOrEmpty] (#stringShouldBeNullOrEmptyExample)

[ShouldNotBeNullOrEmpty] (#stringShouldNotBeNullOrEmptyExample)

####Dictionary

[ShouldContainKey] (#dictionaryShouldContainKeyExample)

[ShouldContainKeyAndValue] (#dictionaryShouldContainKeyAndValueExample)

[ShouldNotContainKey] (#dictionaryShouldNotContainKeyExample)

[ShouldNotContainValueForKey] (#dictionaryShouldNotContainValueForKeyExample)

####Exceptions

[Should.Throw(Action)] (#exceptionsShouldThrowActionExample)

[Should.NotThrow(Action)] (#exceptionsShouldNotThrowActionExample)

[Should.Throw(Func[, Timeout])] (#exceptionsShouldThrowFuncExample)

[Should.NotThrow(Func[, Timeout])] (#exceptionsShouldNotThrowFuncExample)

Task overloads for Should.Throw are blocking and will automatically timeout after 10 seconds (specified in ShouldlyConfiguration.DefaultTaskTimeout)

Tasks

[CompleteIn] (#tasksCompleteInExample)

Dynamic

[ShouldHaveProperty] (#dynamicShouldHaveProperty)

Examples

All the example use the following classes.

namespace Simpsons
{
    public abstract class Pet
    {
        public abstract string Name { get; set; }
    }
}

namespace Simpsons
{
    public class Cat : Pet
    {
        public override string Name { get; set; }
    }
}

namespace Simpsons
{
    public class Dog : Pet
    {
        public override string Name { get; set; }
    }
}

namespace Simpsons
{
    public class Person
    {
        public string Name { get; set; }
        public int Salary { get; set; }
    }
}

Equality - ShouldBe

Using the classes defined here, the following test ...

[Test]
public void ShouldBe()
{
    var theSimpsonsCat = new Cat() { Name = "Santas little helper" };
    theSimpsonsCat.Name.ShouldBe("Snowball 2");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    theSimpsonsCat.Name
        should be
    "Snowball 2"
        but was
    "Santas little helper"

Equality - ShouldBeOneOf

Using the classes defined here, the following test ...

[Test]
public void ShouldBeOneOf()
{
    var apu = new Person() { Name = "Apu" };
    var homer = new Person() { Name = "Homer" };
    var skinner = new Person() { Name = "Skinner" };
    var barney = new Person() { Name = "Barney" };
    var theBeSharps = new List<Person>() { homer, skinner, barney };

    apu.ShouldBeOneOf(theBeSharps.ToArray());
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    apu
        should be one of
    [Simpsons.Person, Simpsons.Person, Simpsons.Person]
        but was
    Simpsons.Person

Equality - ShouldNotBe

Using the classes defined here, the following test ...

[Test]
public void ShouldNotBe()
{
    var theSimpsonsCat = new Cat() { Name = "Santas little helper" };
    theSimpsonsCat.Name.ShouldNotBe("Santas little helper");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    theSimpsonsCat.Name
        should not be
    "Santas little helper"
        but was
    "Santas little helper"

Equality - ShouldNotBeOneOf

Using the classes defined here, the following test ...

[Test]
public void ShouldNotBeOneOf()
{
    var apu = new Person() { Name = "Apu" };
    var homer = new Person() { Name = "Homer" };
    var skinner = new Person() { Name = "Skinner" };
    var barney = new Person() { Name = "Barney" };
    var wiggum = new Person() { Name = "Wiggum" };
    var theBeSharps = new List<Person>() { apu, homer, skinner, barney, wiggum };

    wiggum.ShouldNotBeOneOf(theBeSharps.ToArray());
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    wiggum
        should not be one of
    [Simpsons.Person, Simpsons.Person, Simpsons.Person, Simpsons.Person, Simpsons.Person]
        but was
    Simpsons.Person

Equality - ShouldBeGreaterThan

Using the classes defined here, the following tests ...

[Test]
public void ShouldBeGreaterThan_Example_1()
{
    1.ShouldBeGreaterThan(2);
}

[Test]
public void ShouldBeGreaterThan_Example_2()
{
    var mrBurns = new Person() { Name = "Mr. Burns", Salary = 30000 };
    mrBurns.Salary.ShouldBeGreaterThan(300000000);
}

... shows the following messages on failure ...

Shouldly.ChuckedAWobbly : 
    1
        should be greater than
    2
        but was
    1

Shouldly.ChuckedAWobbly : 
    mrBurns.Salary
        should be greater than
    300000000
        but was
    30000

Equality - ShouldBeLessThan

Using the classes defined here, the following test ...

[Test]
public void ShouldBeLessThan()
{
    var homer = new Person() { Name = "Homer", Salary = 300000000 };
    homer.Salary.ShouldBeLessThan(30000);
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    homer.Salary
        should be less than
    30000
        but was
    300000000

Equality - ShouldBeOfType

Using the classes defined here, the following test ...

[Test]
public void ShouldBeOfType()
{
    var theSimpsonsDog = new Cat() { Name = "Santas little helper" };
    theSimpsonsDog.ShouldBeOfType<Dog>();
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    theSimpsonsDog
        should be of type
    Simpsons.Dog
        but was
    Simpsons.Cat

Equality - ShouldBeAssignableTo

Using the classes defined here, the following test ...

[Test]
public void ShouldBeAssignableTo()
{
    var theSimpsonsDog = new Person() { Name = "Santas little helper" };
    theSimpsonsDog.ShouldBeAssignableTo<Pet>();
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    theSimpsonsDog
        should be assignable to
    Simpsons.Pet
        but was
    Simpsons.Person

Equality - ShouldBeInRange

Using the classes defined here, the following test ...

[Test]
public void ShouldBeInRange()
{
    var homer = new Person() { Name = "Homer", Salary = 300000000 };
    homer.Salary.ShouldBeInRange(30000, 40000);
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    homer.Salary
        should be in range
    { from = 30000, to = 40000 }
        but was
    300000000

Equality - ShouldNotBeInRange

Using the classes defined here, the following test ...

[Test]
public void ShouldNotBeInRange()
{
    var mrBurns = new Person() { Name = "Mr. Burns", Salary = 30000 };
    mrBurns.Salary.ShouldNotBeInRange(30000, 40000);
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    mrBurns.Salary
        should not be in range
    { from = 30000, to = 40000 }
        but was
    30000

Enumerable - ShouldBe

Using the classes defined here, the following test ...

[Test]
public void IEnumerable_ShouldBe()
{
    var apu = new Person() { Name = "Apu" };
    var homer = new Person() { Name = "Homer" };
    var skinner = new Person() { Name = "Skinner" };
    var barney = new Person() { Name = "Barney" };
    var theBeSharps = new List<Person>() { homer, skinner, barney };

    theBeSharps.ShouldBe(new[] {apu, homer, skinner, barney});
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    theBeSharps
        should be
    [Simpsons.Person, Simpsons.Person, Simpsons.Person, Simpsons.Person]
        but was
    [Simpsons.Person, Simpsons.Person, Simpsons.Person]
        difference
    [*Simpsons.Person*, *Simpsons.Person*, *Simpsons.Person*, *]

Enumerable - ShouldAllBe

Using the classes defined here, the following test ...

[Test]
public void IEnumerable_ShouldAllBe_Predicate()
{
    var mrBurns = new Person() { Name = "Mr.Burns", Salary=3000000};
    var kentBrockman = new Person() { Name = "Homer", Salary = 3000000};
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var millionares = new List<Person>() {mrBurns, kentBrockman, homer};

    millionares.ShouldAllBe(m => m.Salary > 1000000);
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    millionares
        should all be an element satisfying the condition
    (m.Salary > 1000000)
        but does not

Enumerable - ShouldContain

Using the classes defined here, the following test ...

[Test]
public void IEnumerable_ShouldContain()
{
    var mrBurns = new Person() { Name = "Mr.Burns", Salary=3000000};
    var kentBrockman = new Person() { Name = "Homer", Salary = 3000000};
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var millionares = new List<Person>() {kentBrockman, homer};

    millionares.ShouldContain(mrBurns);
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    millionares
        should contain
    Simpsons.Person
        but was
    [Simpsons.Person, Simpsons.Person]

Enumerable - ShouldContain

Using the classes defined here, the following test ...

[Test]
public void IEnumerable_ShouldContain_Predicate()
{
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var moe = new Person() { Name = "Moe", Salary=20000};
    var barney = new Person() { Name = "Barney", Salary = 0};
    var millionares = new List<Person>() {homer, moe, barney};

    // Check if at least one element in the IEnumerable satisfies the predicate
    millionares.ShouldContain(m => m.Salary > 1000000);
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    millionares
        should contain an element satisfying the condition
    (m.Salary > 1000000)
        but does not

Enumerable - ShouldNotContain

Using the classes defined here, the following test ...

[Test]
public void IEnumerable_ShouldNotContain()
{
    var homerSimpson = new Person() { Name = "Homer"};
    var homerGlumplich  = new Person() { Name = "Homer"};
    var lenny = new Person() { Name = "Lenny"};
    var carl = new Person() { Name = "carl"};
    var clubOfNoHomers = new List<Person>() {homerSimpson, homerGlumplich, lenny, carl };

    clubOfNoHomers.ShouldNotContain(homerSimpson);
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    clubOfNoHomers
        should not contain
    Simpsons.Person
        but was
    [Simpsons.Person, Simpsons.Person, Simpsons.Person, Simpsons.Person]

Enumerable - ShouldNotContain

Using the classes defined here, the following test ...

[Test]
public void IEnumerable_ShouldNotContain_Predicate()
{
    var mrBurns = new Person() { Name = "Mr.Burns", Salary=3000000};
    var kentBrockman = new Person() { Name = "Homer", Salary = 3000000};
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var millionares = new List<Person>() {mrBurns, kentBrockman, homer};

    millionares.ShouldNotContain(m => m.Salary < 1000000);
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    millionares
        should not contain an element satisfying the condition
    (m.Salary < 1000000)
        but does

Enumerable - ShouldBeEmpty

Using the classes defined here, the following test ...

[Test]
public void IEnumerable_ShouldBeEmpty()
{
    var homer = new Person() { Name = "Homer"};
    var powerPlantOnTheWeekend = new List<Person>() {homer};
    powerPlantOnTheWeekend.ShouldBeEmpty(); 
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    powerPlantOnTheWeekend
            should be empty
        but was [Simpsons.Person]

Enumerable - ShouldNotBeEmpty

Using the classes defined here, the following test ...

[Test]
public void IEnumerable_ShouldNotBeEmpty()
{
    var moesTavernOnTheWeekend = new List<Person>() {};
    moesTavernOnTheWeekend.ShouldNotBeEmpty(); 
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    moesTavernOnTheWeekend
            should not be empty
        but was

Enumerable - ShouldBeOneOf

Using the classes defined here, the following test ...

[Test]
public void IEnumerable_ShouldBeOneOf()
{
    var moe  = new Person() { Name = "Moe"};
    var lenny = new Person() { Name = "Lenny"};
    var carl = new Person() { Name = "carl"};
    var stoneCutters = new List<Person>() { moe, lenny, carl };
    var clubOfNoHomers = new List<Person>() { moe, lenny, carl };

    stoneCutters.ShouldBeOneOf(clubOfNoHomers);
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    stoneCutters
        should be one of
    [[Simpsons.Person, Simpsons.Person, Simpsons.Person]]
        but was
    [Simpsons.Person, Simpsons.Person, Simpsons.Person]
        difference
    [*Simpsons.Person*, *Simpsons.Person*, *Simpsons.Person*]

Enumerable - ShouldBeSubsetOf

Using the classes defined here, the following test ...

[Test]
public void IEnumerable_ShouldBeSubsetOf()
{
    var lisa  = new Person() { Name = "Lisa"};
    var bart = new Person() { Name = "Bart"};
    var maggie = new Person() { Name = "Maggie"};
    var homer = new Person() { Name = "Homer"};
    var marge = new Person() { Name = "Marge"};
    var ralph = new Person() { Name = "Ralph"};
    var simpsonsKids = new List<Person>() { bart, lisa, maggie, ralph };
    var simpsonsFamily = new List<Person>() {lisa, bart, maggie, homer, marge};

    simpsonsKids.ShouldBeSubsetOf(simpsonsFamily);
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    simpsonsKids
        should be subset of 
    [Simpsons.Person, Simpsons.Person, Simpsons.Person, Simpsons.Person, Simpsons.Person]
        but does not

String - ShouldStartWith

Using the classes defined here, the following test ...

[Test]
public void ShouldStartWith()
{
    var lenny = new Person() { Name = "Carl"};
    lenny.Name.ShouldStartWith("Len");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    lenny.Name
        should start with
    "Len"
        but was
    "Carl"

String - ShouldNotStartWith

Using the classes defined here, the following test ...

[Test]
public void ShouldNotStartWith()
{
    var lenny = new Person() { Name = "Carl"};
    lenny.Name.ShouldNotStartWith("Car");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    lenny.Name
        should not start with
    "Car"
        but was
    "Carl"

String - ShouldEndWith

Using the classes defined here, the following test ...

[Test]
public void ShouldEndWith()
{
    var lenny = new Person() { Name = "Carl"};
    lenny.Name.ShouldEndWith("nny");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    lenny.Name
        should end with
    "nny"
        but was
    "Carl"

String - ShouldNotEndWith

Using the classes defined here, the following test ...

[Test]
public void ShouldNotEndWith()
{
    var lenny = new Person() { Name = "Carl"};
    lenny.Name.ShouldNotEndWith("arl");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    lenny.Name
        should not end with
    "arl"
        but was
    "Carl"

String - ShouldContain

Using the classes defined here, the following test ...

[Test]
public void ShouldContain()
{
    var lenny = new Person() { Name = "Carl"};
    lenny.Name.ShouldContain("enn");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    lenny.Name
        should contain
    "enn"
        but was
    "Carl"

String - ShouldNotContain

Using the classes defined here, the following test ...

[Test]
public void ShouldNotContain()
{
    var lenny = new Person() { Name = "Carl"};
    lenny.Name.ShouldNotContain("ar");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    lenny.Name
        should not contain
    "ar"
        but was
    "Carl"

String - ShouldContainWithoutWhitespace

Using the classes defined here, the following test ...

[Test]
public void ShouldContainWithoutWhitespace()
{
    var simpsonDog = new Dog() { Name = "SantasLittleHelperS"};
    simpsonDog.Name.ShouldContainWithoutWhitespace("Santas Little Helper");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    simpsonDog.Name
        should contain without whitespace
    "Santas Little Helper"
        but was
    "SantasLittleHelperS"

String - ShouldMatch

Using the classes defined here, the following test ...

[Test]
public void ShouldMatch()
{
    var simpsonDog = new Dog() { Name = "Santas little helper" };
    simpsonDog.Name.ShouldMatch("Santas Little Helper");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    simpsonDog.Name
        should match
    "Santas Little Helper"
        but was
    "Santas little helper"

String - ShouldBeNullOrEmpty

Using the classes defined here, the following test ...

[Test]
public void ShouldBeNullOrEmpty()
{
    var anonymousClanOfSlackJawedTroglodytes = new Person() {Name = "The Simpsons"};
    anonymousClanOfSlackJawedTroglodytes.Name.ShouldBeNullOrEmpty();
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    anonymousClanOfSlackJawedTroglodytes.Name
            should be null or empty

String - ShouldNotBeNullOrEmpty

Using the classes defined here, the following test ...

[Test]
public void ShouldNotBeNullOrEmpty()
{
    var troyMcClure = new Person() {};
    troyMcClure.Name.ShouldNotBeNullOrEmpty();
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    troyMcClure.Name
            should not be null or empty

Dictionary - ShouldContainKey

Using the classes defined here, the following test ...

[Test]
public void ShouldContainKey()
{
    var websters = new Dictionary<string, string>();
    websters.Add("Embiggen", "To empower or embolden.");
    websters.ShouldContainKey("Cromulent");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
Dictionary
    "websters"
should contain key
            "Cromulent"
but does not

Dictionary - ShouldContainKeyAndValue

Using the classes defined here, the following test ...

[Test]
public void ShouldContainKeyAndValue()
{
    var websters = new Dictionary<string, string>();
    websters.Add("Cromulent", "I never heard the word before moving to Springfield.");

    websters.ShouldContainKeyAndValue("Cromulent", "Fine, acceptable.");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
Dictionary
    "websters"
should contain key
"Cromulent"
with value
            "Fine, acceptable."
but value was "I never heard the word before moving to Springfield."

Dictionary - ShouldNotContainKey

Using the classes defined here, the following test ...

[Test]
public void ShouldNotContainKey()
{
    var websters = new Dictionary<string, string>();
    websters.Add("Chazzwazzers", "What Australians would have called a bull frog.");

    websters.ShouldNotContainKey("Chazzwazzers");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
Dictionary
    "websters"
should not contain key
            "Chazzwazzers"
but does

Dictionary - ShouldNotContainValueForKey

Using the classes defined here, the following test ...

[Test]
public void ShouldNotContainValueForKey()
{
    var websters = new Dictionary<string, string>();
    websters.Add("Chazzwazzers", "What Australians would have called a bull frog.");

    websters.ShouldNotContainValueForKey("Chazzwazzers", "What Australians would have called a bull frog.");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
Dictionary
    "websters"
should not contain key
"Chazzwazzers"
with value
            "What Australians would have called a bull frog."
but does

Exceptions - ShouldThrowAction

Using the classes defined here, the following test ...

[Test]
public void ShouldThrow()
{
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var denominator = 1;
    Should.Throw<DivideByZeroException>(() => { 
                                                var y = homer.Salary/denominator;
                                              });
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    Should
        throw 
    System.DivideByZeroException
        but does not

Exceptions - ShouldNotThrowAction

Using the classes defined here, the following test ...

[Test]
public void ShouldNotThrow()
{
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var denominator = 0;
    Should.NotThrow(() => { 
                            var y = homer.Salary/denominator;
                          });
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    Should
        not throw 
    System.DivideByZeroException
        but does

Exceptions - ShouldThrowFunc

Using the classes defined here, the following test ...

[Test]
public void ShouldThrowFuncOfTask()
{
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var denominator = 1;
    Should.Throw<DivideByZeroException>(() =>
    {
        var task = Task.Factory.StartNew(() => { var y = homer.Salary/denominator; });
        return task;
    });
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    Should
        throw 
    System.DivideByZeroException
        but does not

Exceptions - ShouldNotThrowFunc

Using the classes defined here, the following test ...

[Test]
public void ShouldNotThrowFuncOfTask()
{
    var homer = new Person() { Name = "Homer", Salary = 30000};
    var denominator = 0;
    Should.NotThrow(() =>
    {
        var task = Task.Factory.StartNew(() => { var y = homer.Salary/denominator; });
        return task;
    });
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    Should
        not throw 
    System.DivideByZeroException
        but does

Tasks - CompleteIn

Using the classes defined here, the following test ...

// NOTE: Currently not in the latest Nuget version of Shouldly (version - 2.1.1 )
[Test]
public void CompleteIn()
{
    var homer = new Person() { Name = "Homer", Salary = 30000 };
    var denominator = 1;
    Should.CompleteIn(() =>
    {
        Thread.Sleep(2000);
        var y = homer.Salary / denominator;
    }, TimeSpan.FromSeconds(1));
}

... shows the following message on failure ...

System.TimeoutException : The operation has timed out.

Dynamic - ShouldHaveProperty

Using the classes defined here, the following test ...

// NOTE: Currently not in the latest Nuget version of Shouldly (version - 2.1.1 )
[Test]
public void DynamicShouldHavePropertyTest()
{
    var homerThinkingLikeFlanders = new ExpandoObject();
    DynamicShould.HaveProperty(homerThinkingLikeFlanders, "IAmABigFourEyedLameO");
}

... shows the following message on failure ...

Shouldly.ChuckedAWobbly : 
    Dynamic Object
        "homerThinkingLikeFlanders"
    should contain property
                 "IAmABigFourEyedLameO"
        but does not.

Name		Name	Last commit message	Last commit date
Latest commit History 304 Commits
build		build
lib		lib
packages		packages
src		src
.editorconfig		.editorconfig
.gitattributes		.gitattributes
.gitignore		.gitignore
BREAKING CHANGES.txt		BREAKING CHANGES.txt
LICENSE.txt		LICENSE.txt
NextVersion.txt		NextVersion.txt
README.markdown		README.markdown
ReleaseNotes.md		ReleaseNotes.md
Shouldly.sln		Shouldly.sln

License

ilya-murzinov/shouldly

Folders and files

Latest commit

History

Repository files navigation

Shouldly

How asserting Should be

Tasks

Dynamic

Examples

Equality - ShouldBe

Equality - ShouldBeOneOf

Equality - ShouldNotBe

Equality - ShouldNotBeOneOf

Equality - ShouldBeGreaterThan

Equality - ShouldBeLessThan

Equality - ShouldBeOfType

Equality - ShouldBeAssignableTo

Equality - ShouldBeInRange

Equality - ShouldNotBeInRange

Enumerable - ShouldBe

Enumerable - ShouldAllBe

Enumerable - ShouldContain

Enumerable - ShouldContain

Enumerable - ShouldNotContain

Enumerable - ShouldNotContain

Enumerable - ShouldBeEmpty

Enumerable - ShouldNotBeEmpty

Enumerable - ShouldBeOneOf

Enumerable - ShouldBeSubsetOf

String - ShouldStartWith

String - ShouldNotStartWith

String - ShouldEndWith

String - ShouldNotEndWith

String - ShouldContain

String - ShouldNotContain

String - ShouldContainWithoutWhitespace

String - ShouldMatch

String - ShouldBeNullOrEmpty

String - ShouldNotBeNullOrEmpty

Dictionary - ShouldContainKey

Dictionary - ShouldContainKeyAndValue

Dictionary - ShouldNotContainKey

Dictionary - ShouldNotContainValueForKey

Exceptions - ShouldThrowAction

Exceptions - ShouldNotThrowAction

Exceptions - ShouldThrowFunc

Exceptions - ShouldNotThrowFunc

Tasks - CompleteIn

Dynamic - ShouldHaveProperty

About

Resources

License

Stars

Watchers

Forks

Releases

Packages 0

Languages

Packages