Пример #1
0
        public void MakeFullAutomata(byte[] a_tab, byte[] b_tab, params byte[][] expectedTabs)
        {
            int size = a_tab.Length;

            List <byte>[] TransitionsFromA = new List <byte> [size];
            List <byte>[] helpList         = new List <byte> [size];
            for (byte i = 0; i < size; i++)
            {
                TransitionsFromA[i] = new List <byte>();
            }
            IOptionalAutomaton a = new OptionalAutomaton(a_tab, b_tab);

            MakingFullAutomata makingFullAutomata = new MakingFullAutomata(a, TransitionsFromA, helpList);

            IEnumerable <IOptionalAutomaton> FullAutomata            = makingFullAutomata.Generate();
            IEnumerable <IOptionalAutomaton> FullAutomataIncremental = makingFullAutomata.Generate();

            var fullIterator            = FullAutomata.GetEnumerator();
            var fullIncrementalIterator = FullAutomataIncremental.GetEnumerator();

            while (fullIterator.MoveNext())
            {
                fullIncrementalIterator.MoveNext();
                for (int i = 0; i < fullIterator.Current.TransitionFunctionsB.Length; i++)
                {
                    Assert.Equal(fullIterator.Current.TransitionFunctionsB[i], fullIncrementalIterator.Current.TransitionFunctionsB[i]);
                }
            }
            Assert.False(fullIncrementalIterator.MoveNext());
        }
Пример #2
0
        public void CheckIfDifferentFullFromAcAutomataRecursively(byte[] a_tab, byte[] b_tab)
        {
            int size = a_tab.Length;

            List <byte>[] TransitionsFromA = new List <byte> [size];
            List <byte>[] helpList         = new List <byte> [size];
            for (byte i = 0; i < size; i++)
            {
                TransitionsFromA[i] = new List <byte>();
            }
            IOptionalAutomaton Ac = new OptionalAutomaton(a_tab, b_tab);
            MakingFullAutomata makingFullAutomata = new MakingFullAutomata(Ac, TransitionsFromA, helpList);

            IEnumerable <IOptionalAutomaton> FullAutomata  = makingFullAutomata.Generate();
            IEnumerable <byte[]>             fullAutomata2 =
                from a in FullAutomata
                select CopyArray(a.TransitionFunctionsB);

            byte[][] bTransitions = fullAutomata2.ToArray();
            for (int i = 0; i < bTransitions.Length - 1; i++)
            {
                for (int j = i + 1; j < bTransitions.Length; j++)
                {
                    Assert.NotEqual(bTransitions[i], bTransitions[j]);
                }
            }
        }
Пример #3
0
        public void MakeAcAutomata(byte[] a_tab, byte[] b_tab, params byte[][] expectedTabs)
        {
            IOptionalAutomaton a = new OptionalAutomaton(a_tab, b_tab);

            bool[] isVertTab;
            AddingBTransition.MakeIsVertInAcTabAndGetAcSize(a_tab, out isVertTab);

            AddingBTransition addingBTransition = new AddingBTransition(a, isVertTab);

            IEnumerable <IOptionalAutomaton> AcAutomata = addingBTransition.GenerateAc();

            IEnumerable <byte[]> AcAutomataBTransform =
                from automata in AcAutomata
                select CopyArray(automata.TransitionFunctionsB);

            IsTheSame(expectedTabs, AcAutomataBTransform);
        }
        public static IEnumerable <IOptionalAutomaton> Generate(int size, int seed)
        {
            var a = new byte[size];
            var b = new byte[size];
            var automatonToReturn = new OptionalAutomaton(a, b);
            var random            = new Random(seed);

            while (true)
            {
                for (int i = 0; i < size; i++)
                {
                    a[i] = (byte)(random.Next() % size);
                    b[i] = (byte)(random.Next() % size);
                }
                yield return(automatonToReturn);
            }
        }
Пример #5
0
        public void MakeFromALists(byte[] tab_a, byte[] tab_b, params byte[][] lists)
        {
            IOptionalAutomaton a = new OptionalAutomaton(tab_a, tab_b);

            List <byte>[] expectedList = new List <byte> [lists.Length];
            for (int i = 0; i < expectedList.Length; i++)
            {
                expectedList[i] = new List <byte>(lists[i]);
            }
            int size = tab_a.Length;

            List <byte>[] TransitionsFromA = new List <byte> [size];
            List <byte>[] helpList         = new List <byte> [size];
            for (byte i = 0; i < size; i++)
            {
                TransitionsFromA[i] = new List <byte>();
            }
            MakingFullAutomata makingFullAutomata = new MakingFullAutomata(a, TransitionsFromA, helpList);

            Assert.Equal(expectedList, makingFullAutomata.TransitionsFromA);
        }
Пример #6
0
        public void VerifyMatchingIterativeGeneration(byte[] a_tab, byte[] b_tab, params byte[][] expectedTabs)
        {
            IOptionalAutomaton a = new OptionalAutomaton(a_tab, b_tab);
            int size             = a_tab.Length;

            List <byte>[] TransitionsFromA = new List <byte> [size];
            List <byte>[] helpList         = new List <byte> [size];
            for (byte i = 0; i < size; i++)
            {
                TransitionsFromA[i] = new List <byte>();
            }
            MakingFullAutomata makingFullAutomata = new MakingFullAutomata(a, TransitionsFromA, helpList);

            IEnumerable <IOptionalAutomaton> FullAutomata = makingFullAutomata.Generate();

            IEnumerable <byte[]> AcAutomataBTransform =
                from automata in FullAutomata
                select CopyArray(automata.TransitionFunctionsB);

            IsTheSame(expectedTabs, AcAutomataBTransform);
        }