Esempio n. 1
0
        public void TestBuilder(string input, Type[] atomTypes, string output)
        {
            var builder = new LaTeXBuilder(input);
            var list    = builder.Build();

            Assert.Null(builder.Error);

            CheckAtomTypes(list, atomTypes);

            Assert.Equal(output, LaTeXBuilder.MathListToLaTeX(list).ToString());
        }
Esempio n. 2
0
        public void TestListCopyWithFusedItems()
        {
            var builder = new LaTeXBuilder("12+x");
            var list    = builder.Build();

            var finalized  = list.Clone(true);
            var fusedCount = finalized.Sum(atom => atom.FusedAtoms?.Count ?? 0);

            Assert.Equal(2, fusedCount);

            var copy           = finalized.Clone(true);
            var fusedCopyCount = copy.Sum(atom => atom.FusedAtoms?.Count ?? 0);

            Assert.Equal(2, fusedCopyCount);
        }
Esempio n. 3
0
        public void TestLeftRight(
            string input, Type[] expectedOutputTypes, Type[] expectedInnerTypes,
            string leftBoundary, string rightBoundary, string expectedLatex)
        {
            var builder = new LaTeXBuilder(input);
            var list    = builder.Build();

            Assert.NotNull(list);
            Assert.Null(builder.Error);

            CheckAtomTypes(list, expectedOutputTypes);
            Assert.Single(expectedOutputTypes, t => t == typeof(Inner));
            CheckAtom <Inner>("", inner => {
                CheckAtomTypes(inner.InnerList, expectedInnerTypes);
                Assert.Equal(leftBoundary, inner.LeftBoundary.Nucleus);
                Assert.Equal(rightBoundary, inner.RightBoundary.Nucleus);
            })(list[Array.IndexOf(expectedOutputTypes, typeof(Inner))]);
            Assert.Equal(expectedLatex, LaTeXBuilder.MathListToLaTeX(list).ToString());
        }
Esempio n. 4
0
        public void TestScript(string input, string output, params Type[][] atomTypes)
        {
            RunScriptTest(input, atom => atom.Superscript, atomTypes, output);
            RunScriptTest(input.Replace('^', '_'), atom => atom.Subscript, atomTypes, output.Replace('^', '_'));

            void RunScriptTest
                (string input, Func <MathAtom, MathList> scriptGetter, Type[][] atomTypes, string output)
            {
                var builder = new LaTeXBuilder(input);
                var list    = builder.Build();

                Assert.Null(builder.Error);

                var expandedList = list.Clone(false);

                CheckAtomTypes(expandedList, atomTypes[0]);

                var firstAtom = expandedList[0];
                var types     = atomTypes[1];

                if (types.Length > 0)
                {
                    Assert.NotNull(scriptGetter(firstAtom));
                }

                var scriptList = scriptGetter(firstAtom);

                CheckAtomTypes(scriptList, atomTypes[1]);
                if (atomTypes.Length == 3)
                {
                    // one more level
                    var firstScript      = scriptList[0];
                    var scriptScriptList = scriptGetter(firstScript);
                    CheckAtomTypes(scriptScriptList, atomTypes[2]);
                }

                Assert.Equal(output, LaTeXBuilder.MathListToLaTeX(list).ToString());
            }
        }