test | C# Online Compiler

test by Ionela

using System;
using Shouldly;
using System.Collections.Generic;


/// <summary>
/// This test has two exercises.
/// The requirements are described in the relevant summary section of each class.
/// You will need to write the implementation inside the class of each exercise.
///
/// Before starting this test, press the "Fork" button in the toolbar above and then press save.
/// Press Run once and make sure the console output has no build errors.
/// If you've made no changes and there are build errors, send us an email.
///
/// This program is set up as a Console Application.
///    If you want to work on the test in another IDE, you will have to install the Shouldly nuget package for the tests
/// 
/// The Program.Main method checks the output of each exercise by comparing the result against the expected output.
/// You can use this to test your code.
/// Running the code will make the test fail if the check does not pass.
///
/// Example: check false.ShouldBe(true) - will always fail
///
/// You can also use it to add your own tests if you want to.
/// 
/// Before you are done please make sure the following are true:
/// - Your code is compilable (i.e. it builds successfully)
/// - Your code is indented
/// - You tried to solve all exercises (partial code will still be evaluated)
/// 
/// We will evaluate both the correctitude as well as the quality of your solution    
///
/// When you are done with the test, save the fiddle and send the link to us by email.
///
/// Good luck!
///
/// </summary>

/// <summary>
///   Given a matrix representing the number of grains of sand at a certain position
///   on a table at a fixed point of time, return how much sand falls off the edge of the
///   table when time is unfrozen.
///   Behaviour of the sand:
///   Sand is coarse, rough, irritating and it gets everywhere.
///   The way it does that is the following:
///       - if there are more than 3 grains of sand at a position, it collapses  
///         and one grain of sand falls on each of it's neighbouring positions
///         Ex:
///           0 0 0      0 1 0     
///           0[6]0  ->  1 2 1
///           0 0 0      0 1 0
///
///       - if the sand falls outside the matrix, then it is lost to the wind
///         Ex:
///          [4]0 0      0 1 0
///           0 0 0  ->  1 0 0
///           0 0 0      0 0 0
/// 
///   Longer example:
///
///  [5]3 0 (1)  1[4]0 (2)  2 0 1 (3)  3 0 1 (4)  3 1 1 (5)  3 1 1
///   4 2 0  ->  5 2 0  -> [5]3 0  ->  1[4]0  ->  2 0 1  ->  3 0 1
///   3 1 2      3 1 2      3 1 2      4 1 2     [4]2 2      0 3 2
///
///   - in step (1), there were two grains of sand lost (fallen off the top and left side)
///   - in step (2), there was one grain of sand lost (fallen off the top side)
///   - in step (3), there was one grain of sand lost (fallen off the left side)
///   - in step (4), there were no grains of sand lost
///   - in step (5), there were two grains of sand lost (fallen off the left and bottom side)
///   in total there were 2 + 1 + 1 + 0 + 2 = 6 grains of sand lost
///   
/// </summary>
/// <param name="sandPile">Matrix representing the sand piles on a table. It can have various sizes (not necessarily 3 x 3)</param>
/// <returns>Integer representing the number of grains of sand fallen of the edges.</returns>

/*
	summary
	
	The matrix is traversed and for each value > 3 the CollapseOnNeighbouringPositions function is called. 
	The parameters of this function are the sandPile matrix, and the position of the place where the collapsing takes place, so that we know which neighbors will receive the extra sand.
	When one of the neighbors / all neighbors will also have values > 3 after the collapse, the CollapseOnNeighbouringPositions will be called having the parameters their positions.
	Thus, all positions having values > 3 will be analyzed and the lost sand will be counted.
	
	CollapseInTheCornerPositions, CollapseInTheIntermediatePositions, CollapseInTheMiddlePositions functions will have as parameters :
		the sandPile matrix, the collapsing position and the positions of the neighbors who will receive extra sand
	
*/

public class WastedSandCounter
{
	public int sandLost = 0;

	public int Count(int[,] sandPile)
    {	
		int rows = sandPile.GetLength(0);
		int columns = sandPile.GetLength(1);

		for(int i = 0; i < rows; i++)
		for(int j = 0; j < columns; j++)
		{
			if(sandPile[i, j] > 3)
				sandPile = CollapseOnNeighbouringPositions(sandPile, i, j);
		}

		for(int i = 0; i < rows; i++)
		for(int j = 0; j < columns; j++)
		{
			if(j == 0)
				Console.WriteLine("\n");
			Console.Write(sandPile[i, j]);
			Console.Write(" ");
		}
		Console.WriteLine("\n");

		return sandLost;
		
		throw new NotImplementedException();
	}
	
	public int[,] CollapseOnNeighbouringPositions(int[,] sandPile, int i, int j)
	{
		int rows = sandPile.GetLength(0);
		int columns = sandPile.GetLength(1);
		
		if(i == 0 &&  j== 0){  // top left corner
			sandPile = CollapseInTheCornerPositions(sandPile, i, j, i, j+1, i+1, j);   
			sandLost += 2;	
		}
		else if(i == 0 && j == columns-1){ // top right corner
			sandPile = CollapseInTheCornerPositions(sandPile, i, j, i, j-1, i+1, j);  
			sandLost += 2;	
		}
		else if(i == rows-1 && j == 0) // bottom left corner
		{
			sandPile = CollapseInTheCornerPositions(sandPile, i, j, i-1, j, i, j+1);  
			sandLost += 2;
		} 
		else if(i == rows-1 && j == columns-1){ // bottom right corner
			sandPile = CollapseInTheCornerPositions(sandPile, i, j, i-1, j, i, j-1);
			sandLost += 2;	
		}		 
		else if(i>0 && i<rows-1 && j == 0){ // intermediate rows on the left column
			sandPile = CollapseInTheIntermediatePositions(sandPile,i, j, i-1, j, i, j+1, i+1, j);
			sandLost += 1;
		}
		else if(i>0 && i<rows-1 && j == columns-1){ // intermediate rows on the right column
			sandPile = CollapseInTheIntermediatePositions(sandPile, i, j, i-1, j, i, j-1, i+1, j);	
			sandLost += 1;
		}
		else if(j > 0 && j < columns-1 && i == 0){ // intermediate columns on the top line
			sandPile = CollapseInTheIntermediatePositions(sandPile, i, j, i, j-1, i+1, j, i, j+1);
			sandLost += 1;
		}
		else if(j > 0 && j < columns-1 && i == rows - 1){ // intermediate columns on the bottom line
			sandPile = CollapseInTheIntermediatePositions(sandPile, i, j, i, j-1, i-1, j, i, j+1);
			sandLost += 1;
		} 
		else if(i > 0 && i < rows-1 && j > 0 && j < columns-1){ // positions in the middle of the matrix
			sandPile = CollapseInTheMiddlePositions(sandPile, i, j, i-1, j, i, j+1, i+1, j, i, j-1);
		}
		
		return sandPile;
	}
	
	
	public int[,] CollapseInTheCornerPositions(int[,] sandPile, int i, int j, int neighb_i1, int neighb_j1, int neighb_i2, int neighb_j2)
	{
		sandPile[neighb_i1, neighb_j1] += 1;
		sandPile[neighb_i2, neighb_j2] += 1;
		sandPile[i, j] = sandPile[i, j] - 4;
		
		if(sandPile[i, j] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, i, j);
		if(sandPile[neighb_i1, neighb_j1] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i1, neighb_j1);
		if(sandPile[neighb_i2, neighb_j2] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i2, neighb_j2);
		
		return sandPile;
	}
	
	public int[,] CollapseInTheIntermediatePositions(int[,] sandPile, int i, int j, int  neighb_i1, int  neighb_j1, int  neighb_i2, int  neighb_j2, int  neighb_i3, int  neighb_j3)
	{
		sandPile[neighb_i1, neighb_j1] += 1;
		sandPile[neighb_i2, neighb_j2] += 1;
		sandPile[neighb_i3, neighb_j3] += 1;
		sandPile[i, j] = sandPile[i, j] - 4;
		
		if(sandPile[i, j] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, i, j);
		if(sandPile[neighb_i1, neighb_j1] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i1, neighb_j1);
		if(sandPile[neighb_i2, neighb_j2] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i2, neighb_j2);
		if(sandPile[neighb_i3, neighb_j3] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i3, neighb_j3);
		
		return sandPile;
	}
	
	public int[,] CollapseInTheMiddlePositions(int[,] sandPile, int i, int j, int neighb_i1, int neighb_j1, int neighb_i2, int neighb_j2, int neighb_i3, int neighb_j3, int neighb_i4, int neighb_j4)
	{
		sandPile[neighb_i1, neighb_j1] += 1;
		sandPile[neighb_i2, neighb_j2] += 1;
		sandPile[neighb_i3, neighb_j3] += 1;
		sandPile[neighb_i4, neighb_j4] += 1;
		sandPile[i, j] = sandPile[i, j] - 4;
		
		if(sandPile[i, j] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, i, j);
		if(sandPile[neighb_i1, neighb_j1] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i1, neighb_j1);
		if(sandPile[neighb_i2, neighb_j2] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i2, neighb_j2);
		if(sandPile[neighb_i3, neighb_j3] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i3, neighb_j3);
		if(sandPile[neighb_i4, neighb_j4] > 3)
			sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i4, neighb_j4);
		
		return sandPile;
	}
	
	
}




/// <summary>
/// This part of the code calls the unit tests.
/// It does not contain exercises for this test, but feel free to look around if you want
/// </summary>


public class Program
{
    public static void Main()
    {
        Run();
    }


    private static void Run()
    {
        new WastedSandCounterTests().Start();
       // new MarketplaceTests().Start();
    }
}


/// <summary>
/// This class contains the unit tests for the WastedSandCounter exercise
/// </summary>
public class WastedSandCounterTests
{
    public void Start()
    {
        Tests.Run("WastedSandCounter should", (it) =>
        {
            it.Should(NotCountSandFallingOnTheTable,
                "not count sand that falls on the table");
            it.Should(CountAllSandFallingOffTheTable,
                "count sand that falls off the table");
            it.Should(FullyCollapseTallSandPiles,
                "fully collapse tall piles of the sand");
        });
    }


    public void NotCountSandFallingOnTheTable()
    {
        var counter = new WastedSandCounter();


        var table = new[,]
        {
            { 0, 0, 0 }, 
            { 0, 4, 0 },
            { 0, 0, 0 }
        };


        counter.Count(table).ShouldBe(0);
    }


    public void CountAllSandFallingOffTheTable()
    {
        var counter = new WastedSandCounter();

        var table = new[,]
        {
            { 2, 4, 2 }, 
            { 4, 0, 4 }, 
            { 2, 4, 2 }
        };
		

        counter.Count(table).ShouldBe(12);
    }


    public void FullyCollapseTallSandPiles()
    {
        var counter = new WastedSandCounter();


        var table = new[,]
        {
            { 12, 0, 0 },
            { 0, 0, 0 },
            { 0, 0, 0 }
        };


        counter.Count(table).ShouldBe(6);
    }
}


/// <summary>
/// This class runs the tests and formats the results
/// </summary>


public class Tests
{
    private Tests() { }


    public static void Run(string testGroup, Action<Tests> tests)
    {
        StartTests(testGroup);
        tests(new Tests());
        EndTests();
    }


    public static void StartTests(string testGroup)
    {
        Console.WriteLine("====================================================");
        Console.WriteLine(testGroup);
        Console.WriteLine("====================================================");
    }


    public void Should(Action test, string testName)
    {
        try
        {
            Console.WriteLine(testName);
            test();
            Console.WriteLine("    Passed");
        }
        catch (Exception e)
        {
            Console.WriteLine("    Failed");
            Console.WriteLine("    " + e.Message);
        }
        finally
        {
            Console.WriteLine();
        }
    }


    public static void EndTests()
    {
        Console.WriteLine();
    }
}

​x
 
using System;
using Shouldly;
using System.Collections.Generic;
​
​
/// <summary>
/// This test has two exercises.
/// The requirements are described in the relevant summary section of each class.
/// You will need to write the implementation inside the class of each exercise.
///
/// Before starting this test, press the "Fork" button in the toolbar above and then press save.
/// Press Run once and make sure the console output has no build errors.
/// If you've made no changes and there are build errors, send us an email.
///
/// This program is set up as a Console Application.
///    If you want to work on the test in another IDE, you will have to install the Shouldly nuget package for the tests
/// 
/// The Program.Main method checks the output of each exercise by comparing the result against the expected output.
/// You can use this to test your code.
/// Running the code will make the test fail if the check does not pass.
///
/// Example: check false.ShouldBe(true) - will always fail
///
/// You can also use it to add your own tests if you want to.
/// 
/// Before you are done please make sure the following are true:
/// - Your code is compilable (i.e. it builds successfully)
/// - Your code is indented
/// - You tried to solve all exercises (partial code will still be evaluated)
/// 
/// We will evaluate both the correctitude as well as the quality of your solution    
///
/// When you are done with the test, save the fiddle and send the link to us by email.
///
/// Good luck!
///
/// </summary>
​
/// <summary>
///   Given a matrix representing the number of grains of sand at a certain position
///   on a table at a fixed point of time, return how much sand falls off the edge of the
///   table when time is unfrozen.
///   Behaviour of the sand:
///   Sand is coarse, rough, irritating and it gets everywhere.
///   The way it does that is the following:
///       - if there are more than 3 grains of sand at a position, it collapses  
///         and one grain of sand falls on each of it's neighbouring positions
///         Ex:
///           0 0 0      0 1 0     
///           0[6]0  ->  1 2 1
///           0 0 0      0 1 0
///
///       - if the sand falls outside the matrix, then it is lost to the wind
///         Ex:
///          [4]0 0      0 1 0
///           0 0 0  ->  1 0 0
///           0 0 0      0 0 0
/// 
///   Longer example:
///
///  [5]3 0 (1)  1[4]0 (2)  2 0 1 (3)  3 0 1 (4)  3 1 1 (5)  3 1 1
///   4 2 0  ->  5 2 0  -> [5]3 0  ->  1[4]0  ->  2 0 1  ->  3 0 1
///   3 1 2      3 1 2      3 1 2      4 1 2     [4]2 2      0 3 2
///
///   - in step (1), there were two grains of sand lost (fallen off the top and left side)
///   - in step (2), there was one grain of sand lost (fallen off the top side)
///   - in step (3), there was one grain of sand lost (fallen off the left side)
///   - in step (4), there were no grains of sand lost
///   - in step (5), there were two grains of sand lost (fallen off the left and bottom side)
///   in total there were 2 + 1 + 1 + 0 + 2 = 6 grains of sand lost
///   
/// </summary>
/// <param name="sandPile">Matrix representing the sand piles on a table. It can have various sizes (not necessarily 3 x 3)</param>
/// <returns>Integer representing the number of grains of sand fallen of the edges.</returns>
​
/*
    summary
    
    The matrix is traversed and for each value > 3 the CollapseOnNeighbouringPositions function is called. 
    The parameters of this function are the sandPile matrix, and the position of the place where the collapsing takes place, so that we know which neighbors will receive the extra sand.
    When one of the neighbors / all neighbors will also have values > 3 after the collapse, the CollapseOnNeighbouringPositions will be called having the parameters their positions.
    Thus, all positions having values > 3 will be analyzed and the lost sand will be counted.
    
    CollapseInTheCornerPositions, CollapseInTheIntermediatePositions, CollapseInTheMiddlePositions functions will have as parameters :
        the sandPile matrix, the collapsing position and the positions of the neighbors who will receive extra sand
    
*/
​
public class WastedSandCounter
{
    public int sandLost = 0;
​
    public int Count(int[,] sandPile)
    {   
        int rows = sandPile.GetLength(0);
        int columns = sandPile.GetLength(1);
​
        for(int i = 0; i < rows; i++)
        for(int j = 0; j < columns; j++)
        {
            if(sandPile[i, j] > 3)
                sandPile = CollapseOnNeighbouringPositions(sandPile, i, j);
        }
​
        for(int i = 0; i < rows; i++)
        for(int j = 0; j < columns; j++)
        {
            if(j == 0)
                Console.WriteLine("\n");
            Console.Write(sandPile[i, j]);
            Console.Write(" ");
        }
        Console.WriteLine("\n");
​
        return sandLost;
        
        throw new NotImplementedException();
    }
    
    public int[,] CollapseOnNeighbouringPositions(int[,] sandPile, int i, int j)
    {
        int rows = sandPile.GetLength(0);
        int columns = sandPile.GetLength(1);
        
        if(i == 0 &&  j== 0){  // top left corner
            sandPile = CollapseInTheCornerPositions(sandPile, i, j, i, j+1, i+1, j);   
            sandLost += 2;  
        }
        else if(i == 0 && j == columns-1){ // top right corner
            sandPile = CollapseInTheCornerPositions(sandPile, i, j, i, j-1, i+1, j);  
            sandLost += 2;  
        }
        else if(i == rows-1 && j == 0) // bottom left corner
        {
            sandPile = CollapseInTheCornerPositions(sandPile, i, j, i-1, j, i, j+1);  
            sandLost += 2;
        } 
        else if(i == rows-1 && j == columns-1){ // bottom right corner
            sandPile = CollapseInTheCornerPositions(sandPile, i, j, i-1, j, i, j-1);
            sandLost += 2;  
        }        
        else if(i>0 && i<rows-1 && j == 0){ // intermediate rows on the left column
            sandPile = CollapseInTheIntermediatePositions(sandPile,i, j, i-1, j, i, j+1, i+1, j);
            sandLost += 1;
        }
        else if(i>0 && i<rows-1 && j == columns-1){ // intermediate rows on the right column
            sandPile = CollapseInTheIntermediatePositions(sandPile, i, j, i-1, j, i, j-1, i+1, j);  
            sandLost += 1;
        }
        else if(j > 0 && j < columns-1 && i == 0){ // intermediate columns on the top line
            sandPile = CollapseInTheIntermediatePositions(sandPile, i, j, i, j-1, i+1, j, i, j+1);
            sandLost += 1;
        }
        else if(j > 0 && j < columns-1 && i == rows - 1){ // intermediate columns on the bottom line
            sandPile = CollapseInTheIntermediatePositions(sandPile, i, j, i, j-1, i-1, j, i, j+1);
            sandLost += 1;
        } 
        else if(i > 0 && i < rows-1 && j > 0 && j < columns-1){ // positions in the middle of the matrix
            sandPile = CollapseInTheMiddlePositions(sandPile, i, j, i-1, j, i, j+1, i+1, j, i, j-1);
        }
        
        return sandPile;
    }
    
    
    public int[,] CollapseInTheCornerPositions(int[,] sandPile, int i, int j, int neighb_i1, int neighb_j1, int neighb_i2, int neighb_j2)
    {
        sandPile[neighb_i1, neighb_j1] += 1;
        sandPile[neighb_i2, neighb_j2] += 1;
        sandPile[i, j] = sandPile[i, j] - 4;
        
        if(sandPile[i, j] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, i, j);
        if(sandPile[neighb_i1, neighb_j1] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i1, neighb_j1);
        if(sandPile[neighb_i2, neighb_j2] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i2, neighb_j2);
        
        return sandPile;
    }
    
    public int[,] CollapseInTheIntermediatePositions(int[,] sandPile, int i, int j, int  neighb_i1, int  neighb_j1, int  neighb_i2, int  neighb_j2, int  neighb_i3, int  neighb_j3)
    {
        sandPile[neighb_i1, neighb_j1] += 1;
        sandPile[neighb_i2, neighb_j2] += 1;
        sandPile[neighb_i3, neighb_j3] += 1;
        sandPile[i, j] = sandPile[i, j] - 4;
        
        if(sandPile[i, j] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, i, j);
        if(sandPile[neighb_i1, neighb_j1] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i1, neighb_j1);
        if(sandPile[neighb_i2, neighb_j2] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i2, neighb_j2);
        if(sandPile[neighb_i3, neighb_j3] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i3, neighb_j3);
        
        return sandPile;
    }
    
    public int[,] CollapseInTheMiddlePositions(int[,] sandPile, int i, int j, int neighb_i1, int neighb_j1, int neighb_i2, int neighb_j2, int neighb_i3, int neighb_j3, int neighb_i4, int neighb_j4)
    {
        sandPile[neighb_i1, neighb_j1] += 1;
        sandPile[neighb_i2, neighb_j2] += 1;
        sandPile[neighb_i3, neighb_j3] += 1;
        sandPile[neighb_i4, neighb_j4] += 1;
        sandPile[i, j] = sandPile[i, j] - 4;
        
        if(sandPile[i, j] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, i, j);
        if(sandPile[neighb_i1, neighb_j1] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i1, neighb_j1);
        if(sandPile[neighb_i2, neighb_j2] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i2, neighb_j2);
        if(sandPile[neighb_i3, neighb_j3] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i3, neighb_j3);
        if(sandPile[neighb_i4, neighb_j4] > 3)
            sandPile = CollapseOnNeighbouringPositions(sandPile, neighb_i4, neighb_j4);
        
        return sandPile;
    }
    
    
}
​
​
​
​
/// <summary>
/// This part of the code calls the unit tests.
/// It does not contain exercises for this test, but feel free to look around if you want
/// </summary>
​
​
public class Program
{
    public static void Main()
    {
        Run();
    }
​
​
    private static void Run()
    {
        new WastedSandCounterTests().Start();
       // new MarketplaceTests().Start();
    }
}
​
​
/// <summary>
/// This class contains the unit tests for the WastedSandCounter exercise
/// </summary>
public class WastedSandCounterTests
{
    public void Start()
    {
        Tests.Run("WastedSandCounter should", (it) =>
        {
            it.Should(NotCountSandFallingOnTheTable,
                "not count sand that falls on the table");
            it.Should(CountAllSandFallingOffTheTable,
                "count sand that falls off the table");
            it.Should(FullyCollapseTallSandPiles,
                "fully collapse tall piles of the sand");
        });
    }
​
​
    public void NotCountSandFallingOnTheTable()
    {
        var counter = new WastedSandCounter();
​
​
        var table = new[,]
        {
            { 0, 0, 0 }, 
            { 0, 4, 0 },
            { 0, 0, 0 }
        };
​
​
        counter.Count(table).ShouldBe(0);
    }
​
​
    public void CountAllSandFallingOffTheTable()
    {
        var counter = new WastedSandCounter();
​
        var table = new[,]
        {
            { 2, 4, 2 }, 
            { 4, 0, 4 }, 
            { 2, 4, 2 }
        };
        
​
        counter.Count(table).ShouldBe(12);
    }
​
​
    public void FullyCollapseTallSandPiles()
    {
        var counter = new WastedSandCounter();
​
​
        var table = new[,]
        {
            { 12, 0, 0 },
            { 0, 0, 0 },
            { 0, 0, 0 }
        };
​
​
        counter.Count(table).ShouldBe(6);
    }
}
​
​
/// <summary>
/// This class runs the tests and formats the results
/// </summary>
​
​
public class Tests
{
    private Tests() { }
​
​
    public static void Run(string testGroup, Action<Tests> tests)
    {
        StartTests(testGroup);
        tests(new Tests());
        EndTests();
    }
​
​
    public static void StartTests(string testGroup)
    {
        Console.WriteLine("====================================================");
        Console.WriteLine(testGroup);
        Console.WriteLine("====================================================");
    }
​
​
    public void Should(Action test, string testName)
    {
        try
        {
            Console.WriteLine(testName);
            test();
            Console.WriteLine("    Passed");
        }
        catch (Exception e)
        {
            Console.WriteLine("    Failed");
            Console.WriteLine("    " + e.Message);
        }
        finally
        {
            Console.WriteLine();
        }
    }
​
​
    public static void EndTests()
    {
        Console.WriteLine();
    }
}
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​

View IL Code