using System;

using System.Collections.Generic;

using System.Linq;

using NUnit.Framework;

​

namespace LS{

public class Program

{

    public static void Main()

    {

        var x = new NUnitLite.AutoRun().Execute(new string[]{"--test:LS.Tests", "--noc"});

        Console.WriteLine("");

        Console.WriteLine("----------------------------------------------");

        Console.WriteLine(x==0?"All Test Passed... :¬)": string.Format("{0} tests failed... :¬(", x));

        Console.WriteLine("----------------------------------------------");

    }

}

​

public class ListComparer: IEqualityComparer<Dictionary<string, bool>>

{

    public bool Equals(Dictionary<string, bool>? x, Dictionary<string, bool>? y)

    {

        if (x is null || y is null) return false;

        if (x.Count != y.Count) return false;

​

        foreach (KeyValuePair<string, bool> elem in x)

        {

            if (!y.ContainsKey(elem.Key)) return false;

            else if (elem.Value != y[elem.Key]) return false;

        }

​

         return true;    

   }     

​

   public int GetHashCode( Dictionary<string, bool> obj)

   {

        int hash = 0;

​

        foreach (KeyValuePair<string, bool> elem in obj)

        {

            var _hash = new HashCode();

​

            _hash.Add(elem.Key + elem.Value);

            hash += _hash.ToHashCode();

        }    

        return hash;

   }

​

}

[TestFixture]   

public class Tests

    {

        Dictionary<string, bool> row1_2d, row2_2d, row3_2d, row4_2d,

            reordered_row1_2d, reordered_row2_2d, reordered_row3_2d, reordered_row4_2d,

​

            row1_3d, row2_3d, row3_3d, row4_3d, row5_3d, row6_3d, row7_3d, row8_3d,

            reordered_row1_3d, reordered_row2_3d, reordered_row3_3d, reordered_row4_3d, 

            reordered_row5_3d, reordered_row6_3d, reordered_row7_3d, reordered_row8_3d;

​

        Dictionary<Dictionary<string, bool>, double> cpt;

        ListComparer comparer;

​

        [SetUp]

        public void Setup()

        {

            row1_2d = new Dictionary<string, bool>() { { "B", true }, { "E", true } };

            row2_2d = new Dictionary<string, bool>() { { "B", true }, { "E", false } };

            row3_2d = new Dictionary<string, bool>() { { "B", false }, { "E", true } };

            row4_2d = new Dictionary<string, bool>() { { "B", false }, { "E", false } };

​

            reordered_row1_2d = new Dictionary<string, bool>() { { "E", true }, { "B", true } };

            reordered_row2_2d = new Dictionary<string, bool>() { { "E", false }, { "B", true } };

            reordered_row3_2d = new Dictionary<string, bool>() { { "E", true }, { "B", false } };

            reordered_row4_2d = new Dictionary<string, bool>() { { "E", false }, { "B", false } };

​

            row1_3d = new Dictionary<string, bool>() { { "Cold", false }, { "Flu", false }, { "Malaria", false } };

            row2_3d = new Dictionary<string, bool>() { { "Cold", false }, { "Flu", false }, { "Malaria", true } };

            row3_3d = new Dictionary<string, bool>() { { "Cold", false }, { "Flu", true }, { "Malaria", false } };

            row4_3d = new Dictionary<string, bool>() { { "Cold", false }, { "Flu", true }, { "Malaria", true } };

            row5_3d = new Dictionary<string, bool>() { { "Cold", true }, { "Flu", false }, { "Malaria", false } };

            row6_3d = new Dictionary<string, bool>() { { "Cold", true }, { "Flu", false }, { "Malaria", true } };

            row7_3d = new Dictionary<string, bool>() { { "Cold", true }, { "Flu", true }, { "Malaria", false } };

            row8_3d = new Dictionary<string, bool>() { { "Cold", true }, { "Flu", true }, { "Malaria", true } };

​

            reordered_row1_3d = new Dictionary<string, bool>() { { "Flu", false }, { "Cold", false }, { "Malaria", false } };

            reordered_row2_3d = new Dictionary<string, bool>() { { "Malaria", true }, { "Cold", false }, { "Flu", false } };

            reordered_row3_3d = new Dictionary<string, bool>() { { "Flu", true }, { "Cold", false }, { "Malaria", false } };

            reordered_row4_3d = new Dictionary<string, bool>() { { "Flu", true }, { "Malaria", true }, { "Cold", false }, };

            reordered_row5_3d = new Dictionary<string, bool>() { { "Cold", true }, { "Malaria", false }, { "Flu", false } };

            reordered_row6_3d = new Dictionary<string, bool>() { { "Malaria", true }, { "Flu", false }, { "Cold", true } };

            reordered_row7_3d = new Dictionary<string, bool>() { { "Malaria", false }, { "Flu", true }, { "Cold", true } };

            reordered_row8_3d = new Dictionary<string, bool>() { { "Cold", true }, { "Malaria", true }, { "Flu", true } };

​

​

​

            comparer = new();

​

            cpt = new Dictionary<Dictionary<string, bool>, double>(comparer)

            {

                { row1_2d, 0.95 },

                { row2_2d, 0.94 },

                { row3_2d, 0.29 },

                { row4_2d, 0.001 },

​

                { row1_3d, 0.0 },

                { row2_3d, 0.9 },

                { row3_3d, 0.8 },

                { row4_3d, 0.98 },

                { row5_3d, 0.4 },

                { row6_3d, 0.94 },

                { row7_3d, 0.88 },

                { row8_3d, 0.988 }

            };

        }

​

        [Test]

        public void ProbsAreEqualsTest()

        {

            //For 2d keys

            Assert.AreEqual(cpt[row1_2d], cpt[reordered_row1_2d]);

            Assert.AreEqual(cpt[row2_2d], cpt[reordered_row2_2d]);

            Assert.AreEqual(cpt[row3_2d], cpt[reordered_row3_2d]);

            Assert.AreEqual(cpt[row4_2d], cpt[reordered_row4_2d]);

​

            //For 3d keys

            Assert.AreEqual(cpt[row1_3d], cpt[reordered_row1_3d]);

            Assert.AreEqual(cpt[row2_3d], cpt[reordered_row2_3d]);

            Assert.AreEqual(cpt[row3_3d], cpt[reordered_row3_3d]);

            Assert.AreEqual(cpt[row4_3d], cpt[reordered_row4_3d]);

            Assert.AreEqual(cpt[row5_3d], cpt[reordered_row5_3d]);

            Assert.AreEqual(cpt[row6_3d], cpt[reordered_row6_3d]);

            Assert.AreEqual(cpt[row7_3d], cpt[reordered_row7_3d]);

            Assert.AreEqual(cpt[row8_3d], cpt[reordered_row8_3d]);

        }

​

        [Test]

        public void HashCodeAreEqualsTest()

        {

            //For 2d keys

            Assert.AreEqual(comparer.GetHashCode(row1_2d), comparer.GetHashCode(reordered_row1_2d));

            Assert.AreEqual(comparer.GetHashCode(row2_2d), comparer.GetHashCode(reordered_row2_2d));

            Assert.AreEqual(comparer.GetHashCode(row3_2d), comparer.GetHashCode(reordered_row3_2d));

            Assert.AreEqual(comparer.GetHashCode(row4_2d), comparer.GetHashCode(reordered_row4_2d));

​

            //For 3d keys

            Assert.AreEqual(comparer.GetHashCode(row1_3d), comparer.GetHashCode(reordered_row1_3d));

            Assert.AreEqual(comparer.GetHashCode(row2_3d), comparer.GetHashCode(reordered_row2_3d));

            Assert.AreEqual(comparer.GetHashCode(row3_3d), comparer.GetHashCode(reordered_row3_3d));

            Assert.AreEqual(comparer.GetHashCode(row4_3d), comparer.GetHashCode(reordered_row4_3d));

            Assert.AreEqual(comparer.GetHashCode(row5_3d), comparer.GetHashCode(reordered_row5_3d));

            Assert.AreEqual(comparer.GetHashCode(row6_3d), comparer.GetHashCode(reordered_row6_3d));

            Assert.AreEqual(comparer.GetHashCode(row7_3d), comparer.GetHashCode(reordered_row7_3d));

            Assert.AreEqual(comparer.GetHashCode(row8_3d), comparer.GetHashCode(reordered_row8_3d));

        }

​

        [Test]

        public void HashCodeAreNotEqualsTest()

        {

            //For 2d keys

            Assert.AreNotEqual(comparer.GetHashCode(row2_2d), comparer.GetHashCode(row3_2d));

            Assert.AreNotEqual(comparer.GetHashCode(reordered_row2_2d), comparer.GetHashCode(reordered_row3_2d));

            Assert.AreNotEqual(comparer.GetHashCode(row2_2d), comparer.GetHashCode(reordered_row3_2d));

            Assert.AreNotEqual(comparer.GetHashCode(reordered_row2_2d), comparer.GetHashCode(row3_2d));

​

            //For 3d keys

            Assert.AreNotEqual(comparer.GetHashCode(row2_3d), comparer.GetHashCode(row3_3d));

            Assert.AreNotEqual(comparer.GetHashCode(reordered_row2_3d), comparer.GetHashCode(reordered_row3_3d));

            Assert.AreNotEqual(comparer.GetHashCode(row2_3d), comparer.GetHashCode(reordered_row5_3d));

            Assert.AreNotEqual(comparer.GetHashCode(reordered_row2_3d), comparer.GetHashCode(row5_3d));

        }

​

    }

}