[Fork] Maxcode Internship 2021 | C# Online Compiler

[Fork] Maxcode Internship 2021 by robid98

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>


public class WastedSandCounter
{
/// <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>

		public int checkNeighbouringPos(int[,] sandPile, int i, int j)
		{
			int rows = sandPile.GetLength(0);
			int columns = sandPile.GetLength(1);
			int grainsFallen = 0;
			if (sandPile[i, j] > 3)
			{
				while (sandPile[i, j] > 3)
				{
					sandPile[i, j] -= 4;

					//up
					if (i - 1 < 0)
						grainsFallen += 1;
					else
					{
						sandPile[i - 1, j] += 1;
						grainsFallen += checkNeighbouringPos(sandPile, i - 1, j); // recusrive again

					}


					//left
					if (j - 1 < 0)
						grainsFallen += 1;
					else
					{
						sandPile[i, j - 1] += 1;
						grainsFallen += checkNeighbouringPos(sandPile, i, j - 1); // recusrive again
					}


					//right
					if (j + 1 >= columns)
						grainsFallen += 1;
					else
					{
						sandPile[i, j + 1] += 1;
						grainsFallen += checkNeighbouringPos(sandPile, i, j + 1); // recusrive again
					}

					//down
					if (i + 1 >= rows)
						grainsFallen += 1;
					else
					{
						sandPile[i + 1, j] += 1;
						grainsFallen += checkNeighbouringPos(sandPile, i + 1, j); // recusrive again
					}
				}
			}
			return grainsFallen;
		}

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

			int grainsFallen = 0;

			for (int i = 0; i < rows; i++)
			{
				for (int j = 0; j < columns; j++)
				{
					// Check if the position value > 3
					if (sandPile[i, j] > 3)
					{
						while (sandPile[i, j] > 3)
						{
							sandPile[i, j] -= 4;

							//up
							if (i - 1 < 0)
								grainsFallen += 1;
							else
							{
								sandPile[i - 1, j] += 1;
								grainsFallen += checkNeighbouringPos(sandPile, i - 1, j);
							}


							//left
							if (j - 1 < 0)
								grainsFallen += 1;
							else
							{
								sandPile[i, j - 1] += 1;
								grainsFallen += checkNeighbouringPos(sandPile, i, j - 1);
							}

							//right
							if (j + 1 >= columns)
								grainsFallen += 1;
							else
							{
								sandPile[i, j + 1] += 1;
								grainsFallen += checkNeighbouringPos(sandPile, i, j + 1);
							}

							//down
							if (i + 1 >= rows)
								grainsFallen += 1;
							else
							{
								sandPile[i + 1, j] += 1;
								grainsFallen += checkNeighbouringPos(sandPile, i + 1, j);
							}
						}
					}
				}
			}
			return grainsFallen;
		}
}
/// <summary>
/// A marketplace is a spot where [people], have an [initial inventory] of different [product types] they can trade with each other.
/// 
/// Ex: people = ["Mary", "John"],
///     product types = ["apples", "grapes"],
///     initial inventory = 3
///     This means that:
///         - Mary has 3 apples and 3 grapes
///         - John has 3 apples and 3 grapes.
///     (These values will be processed as constructor parameters)
///
/// Given a list of all the transactions done in the marketplace, a person and a product type,
/// return how many products of that type the person has left after doing the transactions.
///
/// Transactions are strings and can be of two types:
///     Mary sold 2 apples to John
///     Mary bought 1 grapes from John
/// For simplicity, products will have the name given in the product types list, regardless of plurality (1 apples, 2 apples).
/// Transactions will always contain product types and people that are in the people and product types lists.
/// 
/// If a transaction cannot happen, that means it is invalid, and so it is ignored.
/// Subsequent calls to the CheckInventory method should return the same result for the same parameters (state is not kept)
///
/// Example:
///     people = ["Mary", "John"],
///     product types = ["apples", "grapes"],
///     initial inventory = 2
///
///     person: John
///     product type: grapes
///     transactions:
///         "Mary sold 3 apples to John" -- cannot happen, Mary has 2 apples
///         "John bought 1 grapes from Mary" -- John has 3 grapes now, Mary has one grape
///         "John sold 1 apples to Mary" -- John has 1 apple, Mary has 3 apples
///
///     After doing all the transactions, if we check the inventory for John's grapes: John has 3 grapes, so the returned value is 3.
/// </summary>
public class Marketplace
{
    private readonly string[] _people;
    private readonly string[] _productTypes;
    private readonly int _initialInventory;
	private Dictionary<string, Dictionary<string, int>> marketPlaceDataStructure;
    public Marketplace(string[] people, string[] productTypes, int initialInventory)
    {
        _people = people;
        _productTypes = productTypes;
        _initialInventory = initialInventory;
		marketPlaceDataStructure = new Dictionary<string, Dictionary<string, int>>();
    }
	
	void fillMarketStructure()
	{
		for(int i = 0 ; i < this._people.Length; i++)
		{
			if(!this.marketPlaceDataStructure.ContainsKey(this._people[i]))
				this.marketPlaceDataStructure[this._people[i]] = new Dictionary<string, int>();
			
			for(int j = 0 ; j < this._productTypes.Length; j++)
			{
				this.marketPlaceDataStructure[this._people[i]][this._productTypes[j]] = this._initialInventory;
			}
		}
	}


    /// <summary>
    /// Integer representing how much of a "productType" the "person" has in it's inventory after all
    /// the valid transactions are finished.
    /// </summary>
    /// <param name="transactions">List of transactions</param>
    /// <param name="person">Name of the person</param>
    /// <param name="productType">Name of the product type</param>
    /// <returns>Integer representing how much of a "productType" the "person" has.</returns>
    public int CheckInventory(IEnumerable<string> transactions, string person, string productType)
    {
		this.fillMarketStructure();
		
        foreach (string transaction in transactions)
		{
			// tokenzie each transaction to extract the informations
			string[] transactionSplit = transaction.Split(" ");
			string firstName = transactionSplit[0];
			string secondName = transactionSplit[transactionSplit.Length - 1];
			string fruitName = transactionSplit[3];
			string verb = transactionSplit[1]; // bought or sold
			int number = Int32.Parse(transactionSplit[2]);
			
			if(verb.Equals("sold"))
			{
				if(this.marketPlaceDataStructure[firstName][fruitName] >= number)
				{
					this.marketPlaceDataStructure[firstName][fruitName] -= number;
					this.marketPlaceDataStructure[secondName][fruitName] += number;
				}
			}
			else if(verb.Equals("bought"))
			{
				if(this.marketPlaceDataStructure[secondName][fruitName] >= number)
				{
					this.marketPlaceDataStructure[secondName][fruitName] -= number;
					this.marketPlaceDataStructure[firstName][fruitName] += number;
				}
			}
		}
		
		return this.marketPlaceDataStructure[person][productType];
		
    }
}


/// <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");
			it.Should(CustomTest,
                "Custom Test");
        });
    }


    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);
    }
	
	public void CustomTest()
	{
		var counter = new WastedSandCounter();
		
		var table = new[,]
        {
            { 4, 1, 4 },
            { 4, 1, 4 },
            { 4, 1, 4 }
        };
		
		counter.Count(table).ShouldBe(10);
	}
}


/// <summary>
/// This class contains the unit tests for the Marketplace exercise
/// </summary>
public class MarketplaceTests
{
    public void Start()
    {
        Tests.Run("Marketplace should", (it) =>
        {
            it.Should(() => NotDoInvalidTransactions(), "not do transactions that are invalid");
            it.Should(() => DoValidTransactions(), "do transactions that are invalid");
        });
    }


    public void NotDoInvalidTransactions()
    {
        var marketplace = new Marketplace(new []{"Ana", "Ion"}, new []{"apples"}, 3);
        marketplace.CheckInventory(new[] {"Ana sold 4 apples to Ion"}, "Ana", "apples").ShouldBe(3);
        marketplace.CheckInventory(new[] {"Ion bought 4 apples from Ana"}, "Ana", "apples").ShouldBe(3);
    }


    public void DoValidTransactions()
    {
        var marketplace = new Marketplace(new []{"Ana", "Ion"}, new []{"apples"}, 4);
        marketplace.CheckInventory(new[] {"Ana sold 4 apples to Ion", "Ion sold 2 apples to Ana"}, "Ana", "apples").ShouldBe(2);
    }
}


/// <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>
​
​
public class WastedSandCounter
{
/// <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>
​
        public int checkNeighbouringPos(int[,] sandPile, int i, int j)
        {
            int rows = sandPile.GetLength(0);
            int columns = sandPile.GetLength(1);
            int grainsFallen = 0;
            if (sandPile[i, j] > 3)
            {
                while (sandPile[i, j] > 3)
                {
                    sandPile[i, j] -= 4;
​
                    //up
                    if (i - 1 < 0)
                        grainsFallen += 1;
                    else
                    {
                        sandPile[i - 1, j] += 1;
                        grainsFallen += checkNeighbouringPos(sandPile, i - 1, j); // recusrive again
​
                    }
​
​
                    //left
                    if (j - 1 < 0)
                        grainsFallen += 1;
                    else
                    {
                        sandPile[i, j - 1] += 1;
                        grainsFallen += checkNeighbouringPos(sandPile, i, j - 1); // recusrive again
                    }
​
​
                    //right
                    if (j + 1 >= columns)
                        grainsFallen += 1;
                    else
                    {
                        sandPile[i, j + 1] += 1;
                        grainsFallen += checkNeighbouringPos(sandPile, i, j + 1); // recusrive again
                    }
​
                    //down
                    if (i + 1 >= rows)
                        grainsFallen += 1;
                    else
                    {
                        sandPile[i + 1, j] += 1;
                        grainsFallen += checkNeighbouringPos(sandPile, i + 1, j); // recusrive again
                    }
                }
            }
            return grainsFallen;
        }
​
        public int Count(int[,] sandPile)
        {
            int rows = sandPile.GetLength(0);
            int columns = sandPile.GetLength(1);
​
            int grainsFallen = 0;
​
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    // Check if the position value > 3
                    if (sandPile[i, j] > 3)
                    {
                        while (sandPile[i, j] > 3)
                        {
                            sandPile[i, j] -= 4;
​
                            //up
                            if (i - 1 < 0)
                                grainsFallen += 1;
                            else
                            {
                                sandPile[i - 1, j] += 1;
                                grainsFallen += checkNeighbouringPos(sandPile, i - 1, j);
                            }
​
​
                            //left
                            if (j - 1 < 0)
                                grainsFallen += 1;
                            else
                            {
                                sandPile[i, j - 1] += 1;
                                grainsFallen += checkNeighbouringPos(sandPile, i, j - 1);
                            }
​
                            //right
                            if (j + 1 >= columns)
                                grainsFallen += 1;
                            else
                            {
                                sandPile[i, j + 1] += 1;
                                grainsFallen += checkNeighbouringPos(sandPile, i, j + 1);
                            }
​
                            //down
                            if (i + 1 >= rows)
                                grainsFallen += 1;
                            else
                            {
                                sandPile[i + 1, j] += 1;
                                grainsFallen += checkNeighbouringPos(sandPile, i + 1, j);
                            }
                        }
                    }
                }
            }
            return grainsFallen;
        }
}
/// <summary>
/// A marketplace is a spot where [people], have an [initial inventory] of different [product types] they can trade with each other.
/// 
/// Ex: people = ["Mary", "John"],
///     product types = ["apples", "grapes"],
///     initial inventory = 3
///     This means that:
///         - Mary has 3 apples and 3 grapes
///         - John has 3 apples and 3 grapes.
///     (These values will be processed as constructor parameters)
///
/// Given a list of all the transactions done in the marketplace, a person and a product type,
/// return how many products of that type the person has left after doing the transactions.
///
/// Transactions are strings and can be of two types:
///     Mary sold 2 apples to John
///     Mary bought 1 grapes from John
/// For simplicity, products will have the name given in the product types list, regardless of plurality (1 apples, 2 apples).
/// Transactions will always contain product types and people that are in the people and product types lists.
/// 
/// If a transaction cannot happen, that means it is invalid, and so it is ignored.
/// Subsequent calls to the CheckInventory method should return the same result for the same parameters (state is not kept)
///
/// Example:
///     people = ["Mary", "John"],
///     product types = ["apples", "grapes"],
///     initial inventory = 2
///
///     person: John
///     product type: grapes
///     transactions:
///         "Mary sold 3 apples to John" -- cannot happen, Mary has 2 apples
///         "John bought 1 grapes from Mary" -- John has 3 grapes now, Mary has one grape
///         "John sold 1 apples to Mary" -- John has 1 apple, Mary has 3 apples
///
///     After doing all the transactions, if we check the inventory for John's grapes: John has 3 grapes, so the returned value is 3.
/// </summary>
public class Marketplace
{
    private readonly string[] _people;
    private readonly string[] _productTypes;
    private readonly int _initialInventory;
    private Dictionary<string, Dictionary<string, int>> marketPlaceDataStructure;
    public Marketplace(string[] people, string[] productTypes, int initialInventory)
    {
        _people = people;
        _productTypes = productTypes;
        _initialInventory = initialInventory;
        marketPlaceDataStructure = new Dictionary<string, Dictionary<string, int>>();
    }
    
    void fillMarketStructure()
    {
        for(int i = 0 ; i < this._people.Length; i++)
        {
            if(!this.marketPlaceDataStructure.ContainsKey(this._people[i]))
                this.marketPlaceDataStructure[this._people[i]] = new Dictionary<string, int>();
            
            for(int j = 0 ; j < this._productTypes.Length; j++)
            {
                this.marketPlaceDataStructure[this._people[i]][this._productTypes[j]] = this._initialInventory;
            }
        }
    }
​
​
    /// <summary>
    /// Integer representing how much of a "productType" the "person" has in it's inventory after all
    /// the valid transactions are finished.
    /// </summary>
    /// <param name="transactions">List of transactions</param>
    /// <param name="person">Name of the person</param>
    /// <param name="productType">Name of the product type</param>
    /// <returns>Integer representing how much of a "productType" the "person" has.</returns>
    public int CheckInventory(IEnumerable<string> transactions, string person, string productType)
    {
        this.fillMarketStructure();
        
        foreach (string transaction in transactions)
        {
            // tokenzie each transaction to extract the informations
            string[] transactionSplit = transaction.Split(" ");
            string firstName = transactionSplit[0];
            string secondName = transactionSplit[transactionSplit.Length - 1];
            string fruitName = transactionSplit[3];
            string verb = transactionSplit[1]; // bought or sold
            int number = Int32.Parse(transactionSplit[2]);
            
            if(verb.Equals("sold"))
            {
                if(this.marketPlaceDataStructure[firstName][fruitName] >= number)
                {
                    this.marketPlaceDataStructure[firstName][fruitName] -= number;
                    this.marketPlaceDataStructure[secondName][fruitName] += number;
                }
            }
            else if(verb.Equals("bought"))
            {
                if(this.marketPlaceDataStructure[secondName][fruitName] >= number)
                {
                    this.marketPlaceDataStructure[secondName][fruitName] -= number;
                    this.marketPlaceDataStructure[firstName][fruitName] += number;
                }
            }
        }
        
        return this.marketPlaceDataStructure[person][productType];
        
    }
}
​
​
/// <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");
            it.Should(CustomTest,
                "Custom Test");
        });
    }
​
​
    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);
    }
    
    public void CustomTest()
    {
        var counter = new WastedSandCounter();
        
        var table = new[,]
        {
            { 4, 1, 4 },
            { 4, 1, 4 },
            { 4, 1, 4 }
        };
        
        counter.Count(table).ShouldBe(10);
    }
}
​
​
/// <summary>
/// This class contains the unit tests for the Marketplace exercise
/// </summary>
public class MarketplaceTests
{
    public void Start()
    {
        Tests.Run("Marketplace should", (it) =>
        {
            it.Should(() => NotDoInvalidTransactions(), "not do transactions that are invalid");
            it.Should(() => DoValidTransactions(), "do transactions that are invalid");
        });
    }
​
​
    public void NotDoInvalidTransactions()
    {
        var marketplace = new Marketplace(new []{"Ana", "Ion"}, new []{"apples"}, 3);
        marketplace.CheckInventory(new[] {"Ana sold 4 apples to Ion"}, "Ana", "apples").ShouldBe(3);
        marketplace.CheckInventory(new[] {"Ion bought 4 apples from Ana"}, "Ana", "apples").ShouldBe(3);
    }
​
​
    public void DoValidTransactions()
    {
        var marketplace = new Marketplace(new []{"Ana", "Ion"}, new []{"apples"}, 4);
        marketplace.CheckInventory(new[] {"Ana sold 4 apples to Ion", "Ion sold 2 apples to Ana"}, "Ana", "apples").ShouldBe(2);
    }
}
​
​
/// <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();
    }
}
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​

Last Run:	2:52:45 pm
Compile:	0.222s
Execute:	0s
Memory:	32kb
CPU:	0s

View IL Code