Mercurial > hgrepos > Python > libs > pygments-lexer-pseudocode2

comparison tests/test_algpseudo.py @ 105:cec52d83869a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Handle much more characters from the Unicode codeset in expressions. While there: FIX: Add forgotten Punctuation characters `?' and `@'. While there: Allow the escaping of single and double quotes that normally start a string (e.g. for expressions like f' is the first derivation of f).
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 04 May 2026 16:30:36 +0200
parents aae16e3624e2
children 6cebd3e7bc97
comparison
equal deleted inserted replaced
104:ffe6ea2cf69b 105:cec52d83869a
150 ("Name.Entity", "the name"), 150 ("Name.Entity", "the name"),
151 ("Text.Whitespace", "\n"), 151 ("Text.Whitespace", "\n"),
152 ], 152 ],
153 pygments.lex("\\PROC {the name}", self.lexer)) 153 pygments.lex("\\PROC {the name}", self.lexer))
154 154
155 def test_proc_with_symbols_in_name(self):
156 self.assertTokenStreamEqualComplete(
157 [("Keyword", "PROCEDURE"),
158 ("Text.Whitespace", " "),
159 ("Name.Entity", "the name sqrt ! <="),
160 ("Text.Whitespace", "\n"),
161 ],
162 pygments.lex("\\PROC {the name sqrt ! <=}", self.lexer))
163
155 def test_proc_with_escape_in_name(self): 164 def test_proc_with_escape_in_name(self):
156 self.assertTokenStreamEqualComplete( 165 self.assertTokenStreamEqualComplete(
157 [("Keyword", "PROCEDURE"), 166 [("Keyword", "PROCEDURE"),
158 ("Text.Whitespace", " "), 167 ("Text.Whitespace", " "),
159 ("Name.Entity", "t"), 168 ("Name.Entity", "t"),
188 ("Text.Whitespace", " "), 197 ("Text.Whitespace", " "),
189 ("Name.Entity", "the procedure name"), 198 ("Name.Entity", "the procedure name"),
190 ("Text.Whitespace", "\n"), 199 ("Text.Whitespace", "\n"),
191 ], 200 ],
192 pygments.lex("\\END-PROC {the procedure name}", self.lexer)) 201 pygments.lex("\\END-PROC {the procedure name}", self.lexer))
202
203 def test_endproc_with_entityname_3(self):
204 self.assertTokenStreamEqualComplete(
205 [("Keyword", "END OF PROCEDURE"),
206 ("Text.Whitespace", " "),
207 ("Name.Entity", "the procedure name with pow and symbols ! <= "),
208 ("Name.Entity", "}"),
209 ("Name.Entity", "<-"),
210 ("Text.Whitespace", "\n"),
211 ],
212 pygments.lex(
213 "\\END-PROC"
214 " {the procedure name with pow and symbols ! <= \\}<-}",
215 self.lexer))
193 216
194 def test_proc_de(self): 217 def test_proc_de(self):
195 lexer = pygments.lexers.load_lexer_from_file( 218 lexer = pygments.lexers.load_lexer_from_file(
196 ALGLEXERFILENAME, "AlgPseudocodeLexer_DE") 219 ALGLEXERFILENAME, "AlgPseudocodeLexer_DE")
197 self.assertTokenStreamEqualComplete( 220 self.assertTokenStreamEqualComplete(
377 ("Punctuation", ")"), 400 ("Punctuation", ")"),
378 ("Punctuation", ","), 401 ("Punctuation", ","),
379 ("Punctuation", ";"), 402 ("Punctuation", ";"),
380 ("Punctuation", "["), 403 ("Punctuation", "["),
381 ("Punctuation", "]"), 404 ("Punctuation", "]"),
382 ("Text.Whitespace", "\n"), 405 ("Punctuation", "?"),
383 ], 406 ("Punctuation", "@"),
384 pygments.lex(r"{}:(),;[]", self.lexer)) 407 ("Text.Whitespace", "\n"),
408 ],
409 pygments.lex(r"{}:(),;[]?@", self.lexer))
385 410
386 def test_block_empty(self): 411 def test_block_empty(self):
387 self.assertTokenStreamEqualComplete( 412 self.assertTokenStreamEqualComplete(
388 [("Text", "◆"), 413 [("Text", "◆"),
389 ("Text.Whitespace", " "), 414 ("Text.Whitespace", " "),
562 ("Text", " "), 587 ("Text", " "),
563 ("Text.Whitespace", "\n"), 588 ("Text.Whitespace", "\n"),
564 ], 589 ],
565 pygments.lex("\\tt-o/\n\\tt-o// ", self.lexer)) 590 pygments.lex("\\tt-o/\n\\tt-o// ", self.lexer))
566 591
567 @unittest.skipIf(sys.version_info[0] <= 2, "Unicode issue on Python 2")
568 def test_explicit_tokentype_with_remark(self): 592 def test_explicit_tokentype_with_remark(self):
569 self.assertTokenStreamEqualComplete( 593 self.assertTokenStreamEqualComplete(
570 [("Operator", "∈ ∌"), 594 [("Operator", u"∈ ∌"),
571 ("Text", " "), 595 ("Text", " "),
572 ("Comment.Single", "▷"), 596 ("Comment.Single", "▷"),
573 ("Comment.Single", " ∈ ∌ as (ordinary) operators"), 597 ("Comment.Single", u" ∈ ∌ as (ordinary) operators"),
574 ("Text.Whitespace", "\n"), 598 ("Text.Whitespace", "\n"),
575 ], 599 ],
576 pygments.lex( 600 pygments.lex(
577 r"""\ttx-o<∈ ∌> \rem ∈ ∌ as (ordinary) operators""", 601 u"""\\ttx-o<∈ ∌> \\rem ∈ ∌ as (ordinary) operators""",
578 self.lexer)) 602 self.lexer))
579 603
580 def test_explicit_tokentype_with_remark_2(self): 604 def test_explicit_tokentype_with_remark_2(self):
581 self.assertTokenStreamEqualComplete( 605 self.assertTokenStreamEqualComplete(
582 [("Operator", "new_operator"), 606 [("Operator", "new_operator"),
587 ], 611 ],
588 pygments.lex( 612 pygments.lex(
589 r"""\ttx-o<new_operator> \rem a (synthesized) operator""", 613 r"""\ttx-o<new_operator> \rem a (synthesized) operator""",
590 self.lexer)) 614 self.lexer))
591 615
592 @unittest.skipIf(sys.version_info[0] <= 2, "Unicode issue on Python 2")
593 def test_explicit_tokentype_with_possibly_conflicting_parens(self): 616 def test_explicit_tokentype_with_possibly_conflicting_parens(self):
594 self.assertTokenStreamEqualComplete( 617 self.assertTokenStreamEqualComplete(
595 [("Name.Function", "∈_∌"), 618 [("Name.Function", u"∈_∌"),
596 ("Punctuation", "("), 619 ("Punctuation", "("),
597 ("Name.Entity", "p1"), 620 ("Name.Entity", "p1"),
598 ("Punctuation", ","), 621 ("Punctuation", ","),
599 ("Text", " "), 622 ("Text", " "),
600 ("Name.Entity", "p2"), 623 ("Name.Entity", "p2"),
601 ("Punctuation", ")"), 624 ("Punctuation", ")"),
602 ("Text.Whitespace", "\n"), 625 ("Text.Whitespace", "\n"),
603 ], 626 ],
604 pygments.lex( 627 pygments.lex(
605 r"""\ttx-nf<∈_∌>(p1, p2)""", 628 u"""\\ttx-nf<∈_∌>(p1, p2)""",
606 self.lexer)) 629 self.lexer))
607 630
608 def test_explicit_tokentype_with_possibly_conflicting_parens_2(self): 631 def test_explicit_tokentype_with_possibly_conflicting_parens_2(self):
609 self.assertTokenStreamEqualComplete( 632 self.assertTokenStreamEqualComplete(
610 [("Name.Decorator", "a_Decorator"), 633 [("Name.Decorator", "a_Decorator"),
670 ], 693 ],
671 pygments.lex( 694 pygments.lex(
672 r"""\begin \end \end-fn \end-fn {An End of a Function}""" 695 r"""\begin \end \end-fn \end-fn {An End of a Function}"""
673 r""" \end fn {The End of the Next Function} """, 696 r""" \end fn {The End of the Next Function} """,
674 self.lexer)) 697 self.lexer))
698
699 def test_unicode_math_operator(self):
700 self.assertTokenStreamEqualComplete(
701 [("Operator", u"∈"),
702 ("Text.Whitespace", "\n"),
703 ],
704 pygments.lex(u"∈", self.lexer))
705
706 def test_ascii_math_operator(self):
707 self.assertTokenStreamEqualComplete(
708 [("Operator", "="),
709 ("Operator", "!"),
710 ("Operator", "&"),
711 ("Operator", "<"),
712 ("Text", " "),
713 ("Operator", ">"),
714 ("Operator", "+"),
715 ("Operator", "-"),
716 ("Operator", "*"),
717 ("Operator", "/"),
718 ("Operator", "%"),
719 ("Operator", "|"),
720 ("Operator", "~"),
721 ("Text.Whitespace", "\n"),
722 ],
723 pygments.lex("=!&< >+-*/%|~", self.lexer))
724
725 @unittest.skipIf(sys.version_info[0] <= 2, "Unicode issues on Python 2")
726 def test_ascii_math_operator_with_replacements(self):
727 self.assertTokenStreamEqualComplete(
728 [("Operator", u"⇔"),
729 ("Text", " "),
730 ("Operator", u"↔"),
731 ("Text", " "),
732 ("Operator", u"←"),
733 ("Text", " "),
734 ("Operator", u"→"),
735 ("Text", " "),
736 ("Operator", u"⇒"),
737 ("Text", " "),
738 ("Operator", u"≤"),
739 ("Text", " "),
740 ("Operator", u"≥"),
741 ("Text", " "),
742 ("Operator", u"≠"),
743 ("Text", " "),
744 ("Operator", u"≠"),
745 ("Text", " "),
746 ("Operator", u"∶="), # u"≔"),
747 ("Text", " "),
748 ("Operator", u"=∶"), # u"≕"),
749 ("Text", " "),
750 ("Operator", u"≟"),
751 ("Text.Whitespace", "\n"),
752 ],
753 pygments.lex(u"<=> <-> <- -> => <= >= <> != := =: ?=", self.lexer))
754
755 def test_word_operators(self):
756 self.assertTokenStreamEqualComplete(
757 [("Operator.Word", "IN"),
758 ("Text", " "),
759 ("Operator.Word", "is"),
760 ("Text", " "),
761 ("Operator.Word", "And"),
762 ("Text", " "),
763 ("Operator.Word", "Or"),
764 ("Text", " "),
765 ("Operator.Word", "XOR"),
766 ("Text", " "),
767 ("Operator.Word", "not"),
768 ("Text.Whitespace", "\n"),
769 ],
770 pygments.lex("IN is And Or XOR not", self.lexer))
771
772 def test_keyword_constants(self):
773 self.assertTokenStreamEqualComplete(
774 [("Keyword.Constant", "true"),
775 ("Text", " "),
776 ("Keyword.Constant", "FALSE"),
777 ("Text", " "),
778 ("Keyword.Constant", "None"),
779 ("Text", " "),
780 ("Keyword.Constant", "nil"),
781 ("Text", " "),
782 ("Keyword.Constant", "NULL"),
783 ("Text", " "),
784 ("Keyword.Constant", "Empty"),
785 ("Text.Whitespace", "\n"),
786 ],
787 pygments.lex("true FALSE None nil NULL Empty", self.lexer))
788
789 def test_math_builtins(self):
790 self.assertTokenStreamEqualComplete(
791 [("Name.Builtin", "sqrt"),
792 ("Punctuation", "("),
793 ("Name.Entity", "Foo"),
794 ("Punctuation", ")"),
795 ("Punctuation", ";"),
796 ("Text.Whitespace", "\n"),
797 ],
798 pygments.lex("sqrt(Foo);", self.lexer))
799
800 def test_math_builtins_nested(self):
801 self.assertTokenStreamEqualComplete(
802 [("Name.Builtin", "pow"),
803 ("Punctuation", "("),
804 ("Number.Integer", "2"),
805 ("Punctuation", ","),
806 ("Text", " "),
807 ("Number.Integer", "8"),
808 ("Punctuation", ")"),
809 ("Punctuation", ";"),
810 ("Text.Whitespace", "\n"),
811 ],
812 pygments.lex("\\text{\\expr{pow(2, 8);}}", self.lexer))
813
814 def test_math_letters(self):
815 self.assertTokenStreamEqualComplete(
816 [("Name.Entity", "a"),
817 ("Text", " "),
818 ("Operator.Word", "in"),
819 ("Text", " "),
820 ("Name.Entity", u"ℂ"),
821 ("Text.Whitespace", "\n"),
822 ],
823 pygments.lex(u"a in ℂ", self.lexer))
824
825 def test_other_symbols(self):
826 self.assertTokenStreamEqualComplete(
827 [("Name.Entity", "b"),
828 ("Text", " "),
829 ("Operator.Word", "in"),
830 ("Text", " "),
831 ("Text", u"℀"),
832 ("Text.Whitespace", "\n"),
833 ],
834 pygments.lex(u"b in ℀", self.lexer))
835
836 def test_escaped_string_start_1(self):
837 self.assertTokenStreamEqualComplete(
838 [("Text", "flow "),
839 ("Name.Entity", "f"),
840 ("Punctuation", "'"),
841 ("Text.Whitespace", "\n"),
842 ],
843 pygments.lex(r"\TEXT{flow \expr{f\'}}", self.lexer))
844
845 def test_escaped_string_start_2(self):
846 self.assertTokenStreamEqualComplete(
847 [("Text", "flow "),
848 ("Name.Entity", "f"),
849 ("Punctuation", '"'),
850 ("Text.Whitespace", "\n"),
851 ],
852 pygments.lex(r'\TEXT{flow \expr{f\"}}', self.lexer))
675 853
676 854
677 class PygmentizeCompletely(unittest.TestCase): 855 class PygmentizeCompletely(unittest.TestCase):
678 856
679 def setUp(self): 857 def setUp(self):