AIMA.Test.Core.Unit.Logic.FOL.KB.Data.ClauseTest.testBinaryResolventsOrderDoesNotMatter C# (CSharp) Method

        public void testBinaryResolventsOrderDoesNotMatter()
        {
            // This is a regression test, to ensure
            // the ordering of resolvents does not matter.
            // If the order ends up mattering, then likely
            // a problem was introduced in the Clause class
            // unifier, or related class.

            // Set up the initial set of clauses based on the
            // loves animal domain as it contains functions
            // new clauses will always be created (i.e. is an
            // infinite universe of discourse).
            FOLKnowledgeBase kb = new FOLKnowledgeBase(DomainFactory
                    .lovesAnimalDomain());

            kb
                    .tell("FORALL x (FORALL y (Animal(y) => Loves(x, y)) => EXISTS y Loves(y, x))");
            kb
                    .tell("FORALL x (EXISTS y (Animal(y) AND Kills(x, y)) => FORALL z NOT(Loves(z, x)))");
            kb.tell("FORALL x (Animal(x) => Loves(Jack, x))");
            kb.tell("(Kills(Jack, Tuna) OR Kills(Curiosity, Tuna))");
            kb.tell("Cat(Tuna)");
            kb.tell("FORALL x (Cat(x) => Animal(x))");

            List<Clause> clauses = new List<Clause>();
            clauses.AddRange(kb.getAllClauses());

            List<Clause> newClauses = new List<Clause>();
            long maxRunTime = 30 * 1000; // 30 seconds
            long finishTime = System.DateTime.UtcNow.Ticks + maxRunTime;
            do
            {
                clauses.AddRange(newClauses);
                newClauses.Clear();
                Clause[] clausesA = new Clause[clauses.Count];
                clauses.CopyTo(clausesA);
                for (int i = 0; i < clausesA.Length; i++)
                {
                    Clause cI = clausesA[i];
                    for (int j = 0; j < clausesA.Length; j++)
                    {
                        Clause cJ = clausesA[j];

                        newClauses.AddRange(cI.getFactors());
                        newClauses.AddRange(cJ.getFactors());

                        List<Clause> cIresolvents = cI.binaryResolvents(cJ);
                        List<Clause> cJresolvents = cJ.binaryResolvents(cI);
                        if (!cIresolvents.Equals(cJresolvents))
                        {
                            System.Console.WriteLine("cI=" + cI);
                            System.Console.WriteLine("cJ=" + cJ);
                            System.Console.WriteLine("cIR=" + cIresolvents);
                            System.Console.WriteLine("cJR=" + cJresolvents);
                            Assert
                                    .Fail("Ordering of binary resolvents has become usingant, which should not be the case");
                        }

                        foreach (Clause r in cIresolvents)
                        {
                            newClauses.AddRange(r.getFactors());
                        }

                        if (System.DateTime.UtcNow.Ticks > finishTime)
                        {
                            break;
                        }
                    }
                    if (System.DateTime.UtcNow.Ticks > finishTime)
                    {
                        break;
                    }
                }
            } while (System.DateTime.UtcNow.Ticks < finishTime);
        }