[Fork] [Fork] MaxcodeInternship2022Autumn | C# Online Compiler

[Fork] [Fork] MaxcodeInternship2022Autumn by Vlad Grigorita

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

/// <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 made no changes and there are build errors, send an email to us.
///
/// 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 make sure the following is true:
/// - Your code is compilable
/// - Your code is indented
/// - You tried to solve all exercises (partial code will still be evaluated)
///
/// When you are done with the test, save the fiddle and send the link to us by email.
///
/// Good luck!
///
/// </summary>

/// <summary>
/// An ATM machine starts with an initial amount of money. 
/// The money available in the ATM is provided as a dictionary where 
/// every key is the denomination and the associated value represents the amount available for that denomination.
/// 
/// For example, given the input:
///     { ( 1, 3 ), ( 5, 2 ), ( 10, 4 ) }
/// The ATM machine will contain:
///     - 3 bills of 1 RON
///     - 2 bills of 5 RON
///     - 4 bills of 10 RON
///     
/// The ATM Machine allows people to withdraw money multiple times, by calling the <see cref="Withdraw(int)"/>
/// </summary>
public class AtmMachine
{
    private Dictionary<int, int> _amounts;

    public AtmMachine(Dictionary<int, int> amounts)
    {
        this._amounts = amounts;
    }

    /// <summary>
    /// By using the <see cref="Withdraw(int)"/> method, people can attempt to withdraw money.
    /// If the amount is not available in the ATM, the person must receive an empty `List<Tuple<int, int>>`
    /// If the amount is available in the ATM, the person will receive a `List<Tuple<int, int>>` representing all the denominations and units they receive.
    /// For instance:
    ///     Given the ATM has an initial balance of 
    ///         { { 1, 10 }, { 5, 10 }, { 10, 10 } }
    ///     When attempting to withdraw 
    ///         27 RON
    ///     Then the method could return(*)
    ///         { (10, 2), (5, 1), (1, 2) }
    ///     Which means
    ///         - 2 bills of 10 RON
    ///         - 1 bill of 5 RON
    ///         - 2 bills of 1 RON
    /// 
    /// (*)Note: other variations are also acceptable. 
    /// </summary>
    public List<Tuple<int, int>> Withdraw(int amount)
    {
            int moneyAvailable = 0;
    Dictionary < int, int > resultsMap = new Dictionary < int, int > {};
    //Console.WriteLine("Withdral:" + amount);

    //Console.WriteLine("Money in bank:");
    for (int i = 0; i < _amounts.Count; ++i) {
      //Console.WriteLine(_amounts.ElementAt(i));
      moneyAvailable += _amounts.ElementAt(i).Key * _amounts[_amounts.ElementAt(i).Key];
    }

    if (moneyAvailable >= amount && amount > 0) {

      for (int i = _amounts.Count() - 1; i >= 0;) {
        if (_amounts.ElementAt(i).Key <= amount) {
          if (resultsMap.ContainsKey(_amounts.ElementAt(i).Key)) {
            resultsMap[_amounts.ElementAt(i).Key]++;
          } else {
            resultsMap.Add(_amounts.ElementAt(i).Key, 1);
          }

          amount -= _amounts.ElementAt(i).Key;

          _amounts[_amounts.ElementAt(i).Key]--;
          if (_amounts[_amounts.ElementAt(i).Key] == 0) {
            _amounts.Remove(_amounts[_amounts.ElementAt(i).Key]);
            i--;
          }
        } else i--;

      }

    }

    List < Tuple < int, int >> list = new List < Tuple < int, int >> {};

    //Console.WriteLine("=====Solution Begin=====");
    for (int i = 0; i < resultsMap.Count; ++i) {
      list.Add(new Tuple < int, int > (resultsMap.ElementAt(i).Key,
        resultsMap[resultsMap.ElementAt(i).Key]));
      //Console.WriteLine(list.ElementAt(i));
    }
    //Console.WriteLine("=====Solution End=====");

    return list;
    }
}


/// <summary>
/// Version numbers consist of one or more revisions joined by a dot '.'
/// Each revision consists of digits and may contain leading zeros.
/// Every revision contains at least one character.
/// Revisions are 0-indexed from left to right. The leftmost revision is revision 0, the next - revision 1, and so on.
/// For example 3.44.2 and 0.1 are valid version numbers.
/// </summary>
public class VersionComparer
{
    /// <summary>
    /// Compare the provided version strings.
    /// To compare version numbers, compare their revisions in left-to-right order.
    /// Revisions are compared using their integer value, ignoring any leading zeros (revision 1 and 0001 are equal).
    /// If a version number doesn't specify a revision at an index, the revision should be treated as 0.
    /// For example, comparing 'version 1.0' and 'version 1.1' should return that `version 1.1` is greater than `version 1.0`
    /// </summary>
    /// <returns>
    ///  1 when `versionOne` > `versionTwo`
    ///  0 when `versionOne` == `versionTwo`
    /// -1 when `versionOne` < `versionTwo`
    /// </returns>
    public int Compare(string versionOne, string versionTwo)
    {
            //Console.WriteLine(versionOne);
    List < int > version1 = new List < int > {};
    List < int > version2 = new List < int > {};
    List < int > templist = new List < int > {};

    string[] words1 = versionOne.Split(".");
    for (int i = 0; i < words1.Count(); ++i) {
      int temp = Int32.Parse(words1[i]);

      templist.Clear();
      if (temp == 0) templist.Add(0);
      while (temp > 0) {
        templist.Add(temp % 10);
        temp /= 10;
      }
      templist.Reverse();
      version1.AddRange(templist);
      //version1.Add(temp);
      //Console.WriteLine(version1[i]);
    }

    //Console.WriteLine(versionTwo);
    string[] words2 = versionTwo.Split(".");
    for (int i = 0; i < words2.Count(); ++i) {
      int temp = Int32.Parse(words2[i]);

      templist.Clear();
      if (temp == 0) templist.Add(0);
      while (temp > 0) {
        templist.Add(temp % 10);
        temp /= 10;
      }
      templist.Reverse();
      version2.AddRange(templist);
      //Console.WriteLine(version2[i]);
    }
    while (version1.Count < version2.Count) {
      version1.Add(0);
    }

    while (version2.Count < version1.Count) {
      version2.Add(0);
    }

    //Console.WriteLine("Problem:" + versionOne + " " + versionTwo);
    for (int i = 0; i < version1.Count; ++i) {
      //	Console.Write(version1[i] + " ");
    }
    //Console.Write("\n");
    for (int i = 0; i < version1.Count; ++i) {
      //	Console.Write(version2[i] + " ");
    }
    //Console.Write("\nResult: \n");

    for (int i = 0; i < version1.Count; ++i) {
      if (version1[i] < version2[i]) {
        //Console.WriteLine("-1");
        return -1;
      }
      if (version1[i] > version2[i]) {
        //Console.WriteLine("1");
        return 1;
      }
    }

    //Console.WriteLine("Finished");
    return 0;

    }

}


/// <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 AtmMachineTests().Start();
        new VersionComparerTests().Start();
    }
}



public class AtmMachineTests
{
    public void Start()
    {
        Tests.Run($"{nameof(AtmMachine)} should", (it) =>
        {
            it.Should(() => NotProcessNegativeValues(), "Not process negative values");
            it.Should(() => ReturnMultipleDenominationAmounts(), "Return multiple denomination amounts");
            it.Should(() => NotProcessWithdrawalsWhenInventoryIsSmallerThanRequestedAmount(), "Not process witdrawals greater than inventory");
            it.Should(() => ReturnAllAvailableMoney(), "Return all available money");
            it.Should(() => KeepStateBetweenWithdrawals(), "Keep state between withdrawals");
            it.Should(() => NotChangeStateIfWithdrawalIsntSuccessful(), "Not change state if withdrawal isn't successful");
        });
    }

    private int CountMoney(List<Tuple<int, int>> amounts) => amounts.Aggregate(0, (a, i) => a + i.Item1 * i.Item2);

    public void NotChangeStateIfWithdrawalIsntSuccessful()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 }, { 5, 5 }, { 10, 5 } });

        var r1 = atm.Withdraw(50);
        CountMoney(r1).ShouldBe(50);

        var r2 = atm.Withdraw(50);
        CountMoney(r2).ShouldBe(0);

        var r3 = atm.Withdraw(20);
        CountMoney(r3).ShouldBe(20);
    }

    public void NotProcessNegativeValues()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 } });
        var result = atm.Withdraw(-5);
        CountMoney(result).ShouldBe(0);
    }

    public void KeepStateBetweenWithdrawals()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 }, { 5, 5 } });
        var r1 = atm.Withdraw(5);
        CountMoney(r1).ShouldBe(5);
        var r2 = atm.Withdraw(26);
        CountMoney(r2).ShouldBe(0);
    }

    public void ReturnAllAvailableMoney()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 }, { 50, 10 }, { 100, 10 }, { 200, 10 }, { 500, 10 } });
        var result = atm.Withdraw(8660);
        var sum = CountMoney(result);
        sum.ShouldBe(8660);
    }

    public void ReturnMultipleDenominationAmounts()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 } });
        var result = atm.Withdraw(87);
        CountMoney(result).ShouldBe(87);
    }

    public void NotProcessWithdrawalsWhenInventoryIsSmallerThanRequestedAmount()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 }, { 50, 10 }, { 100, 10 }, { 200, 10 }, { 500, 10 } });
        var result = atm.Withdraw(8661);
        CountMoney(result).ShouldBe(0);
    }
}

/// <summary>
/// This class contains the unit tests for the MaxcodeLatinTranslator exercise
/// </summary>
public class VersionComparerTests
{
    public void Start()
    {
        Tests.Run("VersionComparer should", (it) =>
        {
            it.Should(() => CompareEqualVersions(), "Compare equal versions");
            it.Should(() => CompareDifferentVersions(), "Compare different versions");
        });
    }

    public void CompareEqualVersions()
    {
        var comparer = new VersionComparer();
        comparer.Compare("0", "0.0.0").ShouldBe(0);
        comparer.Compare("0.01", "0.1").ShouldBe(0);
        comparer.Compare("1.001", "1.1").ShouldBe(0);
        comparer.Compare("7.015.84", "7.15.84").ShouldBe(0);
        comparer.Compare("7.1", "7.1.0.0").ShouldBe(0);
    }

    public void CompareDifferentVersions()
    {
        var comparer = new VersionComparer();
        comparer.Compare("01.0.1", "1.1.0").ShouldBe(-1);
        comparer.Compare("33.1", "33.0.5").ShouldBe(1);
        comparer.Compare("7.0105.84", "7.15.84").ShouldBe(-1);
    }
}


/// <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;
using System.Linq;
​
/// <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 made no changes and there are build errors, send an email to us.
///
/// 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 make sure the following is true:
/// - Your code is compilable
/// - Your code is indented
/// - You tried to solve all exercises (partial code will still be evaluated)
///
/// When you are done with the test, save the fiddle and send the link to us by email.
///
/// Good luck!
///
/// </summary>
​
/// <summary>
/// An ATM machine starts with an initial amount of money. 
/// The money available in the ATM is provided as a dictionary where 
/// every key is the denomination and the associated value represents the amount available for that denomination.
/// 
/// For example, given the input:
///     { ( 1, 3 ), ( 5, 2 ), ( 10, 4 ) }
/// The ATM machine will contain:
///     - 3 bills of 1 RON
///     - 2 bills of 5 RON
///     - 4 bills of 10 RON
///     
/// The ATM Machine allows people to withdraw money multiple times, by calling the <see cref="Withdraw(int)"/>
/// </summary>
public class AtmMachine
{
    private Dictionary<int, int> _amounts;
​
    public AtmMachine(Dictionary<int, int> amounts)
    {
        this._amounts = amounts;
    }
​
    /// <summary>
    /// By using the <see cref="Withdraw(int)"/> method, people can attempt to withdraw money.
    /// If the amount is not available in the ATM, the person must receive an empty `List<Tuple<int, int>>`
    /// If the amount is available in the ATM, the person will receive a `List<Tuple<int, int>>` representing all the denominations and units they receive.
    /// For instance:
    ///     Given the ATM has an initial balance of 
    ///         { { 1, 10 }, { 5, 10 }, { 10, 10 } }
    ///     When attempting to withdraw 
    ///         27 RON
    ///     Then the method could return(*)
    ///         { (10, 2), (5, 1), (1, 2) }
    ///     Which means
    ///         - 2 bills of 10 RON
    ///         - 1 bill of 5 RON
    ///         - 2 bills of 1 RON
    /// 
    /// (*)Note: other variations are also acceptable. 
    /// </summary>
    public List<Tuple<int, int>> Withdraw(int amount)
    {
            int moneyAvailable = 0;
    Dictionary < int, int > resultsMap = new Dictionary < int, int > {};
    //Console.WriteLine("Withdral:" + amount);
​
    //Console.WriteLine("Money in bank:");
    for (int i = 0; i < _amounts.Count; ++i) {
      //Console.WriteLine(_amounts.ElementAt(i));
      moneyAvailable += _amounts.ElementAt(i).Key * _amounts[_amounts.ElementAt(i).Key];
    }
​
    if (moneyAvailable >= amount && amount > 0) {
​
      for (int i = _amounts.Count() - 1; i >= 0;) {
        if (_amounts.ElementAt(i).Key <= amount) {
          if (resultsMap.ContainsKey(_amounts.ElementAt(i).Key)) {
            resultsMap[_amounts.ElementAt(i).Key]++;
          } else {
            resultsMap.Add(_amounts.ElementAt(i).Key, 1);
          }
​
          amount -= _amounts.ElementAt(i).Key;
​
          _amounts[_amounts.ElementAt(i).Key]--;
          if (_amounts[_amounts.ElementAt(i).Key] == 0) {
            _amounts.Remove(_amounts[_amounts.ElementAt(i).Key]);
            i--;
          }
        } else i--;
​
      }
​
    }
​
    List < Tuple < int, int >> list = new List < Tuple < int, int >> {};
​
    //Console.WriteLine("=====Solution Begin=====");
    for (int i = 0; i < resultsMap.Count; ++i) {
      list.Add(new Tuple < int, int > (resultsMap.ElementAt(i).Key,
        resultsMap[resultsMap.ElementAt(i).Key]));
      //Console.WriteLine(list.ElementAt(i));
    }
    //Console.WriteLine("=====Solution End=====");
​
    return list;
    }
}
​
​
/// <summary>
/// Version numbers consist of one or more revisions joined by a dot '.'
/// Each revision consists of digits and may contain leading zeros.
/// Every revision contains at least one character.
/// Revisions are 0-indexed from left to right. The leftmost revision is revision 0, the next - revision 1, and so on.
/// For example 3.44.2 and 0.1 are valid version numbers.
/// </summary>
public class VersionComparer
{
    /// <summary>
    /// Compare the provided version strings.
    /// To compare version numbers, compare their revisions in left-to-right order.
    /// Revisions are compared using their integer value, ignoring any leading zeros (revision 1 and 0001 are equal).
    /// If a version number doesn't specify a revision at an index, the revision should be treated as 0.
    /// For example, comparing 'version 1.0' and 'version 1.1' should return that `version 1.1` is greater than `version 1.0`
    /// </summary>
    /// <returns>
    ///  1 when `versionOne` > `versionTwo`
    ///  0 when `versionOne` == `versionTwo`
    /// -1 when `versionOne` < `versionTwo`
    /// </returns>
    public int Compare(string versionOne, string versionTwo)
    {
            //Console.WriteLine(versionOne);
    List < int > version1 = new List < int > {};
    List < int > version2 = new List < int > {};
    List < int > templist = new List < int > {};
​
    string[] words1 = versionOne.Split(".");
    for (int i = 0; i < words1.Count(); ++i) {
      int temp = Int32.Parse(words1[i]);
​
      templist.Clear();
      if (temp == 0) templist.Add(0);
      while (temp > 0) {
        templist.Add(temp % 10);
        temp /= 10;
      }
      templist.Reverse();
      version1.AddRange(templist);
      //version1.Add(temp);
      //Console.WriteLine(version1[i]);
    }
​
    //Console.WriteLine(versionTwo);
    string[] words2 = versionTwo.Split(".");
    for (int i = 0; i < words2.Count(); ++i) {
      int temp = Int32.Parse(words2[i]);
​
      templist.Clear();
      if (temp == 0) templist.Add(0);
      while (temp > 0) {
        templist.Add(temp % 10);
        temp /= 10;
      }
      templist.Reverse();
      version2.AddRange(templist);
      //Console.WriteLine(version2[i]);
    }
    while (version1.Count < version2.Count) {
      version1.Add(0);
    }
​
    while (version2.Count < version1.Count) {
      version2.Add(0);
    }
​
    //Console.WriteLine("Problem:" + versionOne + " " + versionTwo);
    for (int i = 0; i < version1.Count; ++i) {
      //    Console.Write(version1[i] + " ");
    }
    //Console.Write("\n");
    for (int i = 0; i < version1.Count; ++i) {
      //    Console.Write(version2[i] + " ");
    }
    //Console.Write("\nResult: \n");
​
    for (int i = 0; i < version1.Count; ++i) {
      if (version1[i] < version2[i]) {
        //Console.WriteLine("-1");
        return -1;
      }
      if (version1[i] > version2[i]) {
        //Console.WriteLine("1");
        return 1;
      }
    }
​
    //Console.WriteLine("Finished");
    return 0;
​
    }
​
}
​
​
/// <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 AtmMachineTests().Start();
        new VersionComparerTests().Start();
    }
}
​
​
​
public class AtmMachineTests
{
    public void Start()
    {
        Tests.Run($"{nameof(AtmMachine)} should", (it) =>
        {
            it.Should(() => NotProcessNegativeValues(), "Not process negative values");
            it.Should(() => ReturnMultipleDenominationAmounts(), "Return multiple denomination amounts");
            it.Should(() => NotProcessWithdrawalsWhenInventoryIsSmallerThanRequestedAmount(), "Not process witdrawals greater than inventory");
            it.Should(() => ReturnAllAvailableMoney(), "Return all available money");
            it.Should(() => KeepStateBetweenWithdrawals(), "Keep state between withdrawals");
            it.Should(() => NotChangeStateIfWithdrawalIsntSuccessful(), "Not change state if withdrawal isn't successful");
        });
    }
​
    private int CountMoney(List<Tuple<int, int>> amounts) => amounts.Aggregate(0, (a, i) => a + i.Item1 * i.Item2);
​
    public void NotChangeStateIfWithdrawalIsntSuccessful()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 }, { 5, 5 }, { 10, 5 } });
​
        var r1 = atm.Withdraw(50);
        CountMoney(r1).ShouldBe(50);
​
        var r2 = atm.Withdraw(50);
        CountMoney(r2).ShouldBe(0);
​
        var r3 = atm.Withdraw(20);
        CountMoney(r3).ShouldBe(20);
    }
​
    public void NotProcessNegativeValues()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 } });
        var result = atm.Withdraw(-5);
        CountMoney(result).ShouldBe(0);
    }
​
    public void KeepStateBetweenWithdrawals()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 5 }, { 5, 5 } });
        var r1 = atm.Withdraw(5);
        CountMoney(r1).ShouldBe(5);
        var r2 = atm.Withdraw(26);
        CountMoney(r2).ShouldBe(0);
    }
​
    public void ReturnAllAvailableMoney()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 }, { 50, 10 }, { 100, 10 }, { 200, 10 }, { 500, 10 } });
        var result = atm.Withdraw(8660);
        var sum = CountMoney(result);
        sum.ShouldBe(8660);
    }
​
    public void ReturnMultipleDenominationAmounts()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 } });
        var result = atm.Withdraw(87);
        CountMoney(result).ShouldBe(87);
    }
​
    public void NotProcessWithdrawalsWhenInventoryIsSmallerThanRequestedAmount()
    {
        var atm = new AtmMachine(new Dictionary<int, int> { { 1, 10 }, { 5, 10 }, { 10, 10 }, { 50, 10 }, { 100, 10 }, { 200, 10 }, { 500, 10 } });
        var result = atm.Withdraw(8661);
        CountMoney(result).ShouldBe(0);
    }
}
​
/// <summary>
/// This class contains the unit tests for the MaxcodeLatinTranslator exercise
/// </summary>
public class VersionComparerTests
{
    public void Start()
    {
        Tests.Run("VersionComparer should", (it) =>
        {
            it.Should(() => CompareEqualVersions(), "Compare equal versions");
            it.Should(() => CompareDifferentVersions(), "Compare different versions");
        });
    }
​
    public void CompareEqualVersions()
    {
        var comparer = new VersionComparer();
        comparer.Compare("0", "0.0.0").ShouldBe(0);
        comparer.Compare("0.01", "0.1").ShouldBe(0);
        comparer.Compare("1.001", "1.1").ShouldBe(0);
        comparer.Compare("7.015.84", "7.15.84").ShouldBe(0);
        comparer.Compare("7.1", "7.1.0.0").ShouldBe(0);
    }
​
    public void CompareDifferentVersions()
    {
        var comparer = new VersionComparer();
        comparer.Compare("01.0.1", "1.1.0").ShouldBe(-1);
        comparer.Compare("33.1", "33.0.5").ShouldBe(1);
        comparer.Compare("7.0105.84", "7.15.84").ShouldBe(-1);
    }
}
​
​
/// <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