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

comparison tests/test_algpseudo.py @ 123:4d96ace53ba1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Make it work on Python2 too with all tests by explicitely declaring some strings to be Unicode strings. No tests need to be skipped on Python2 now.
author Franz Glasner <fzglas.hg@dom66.de>
date Wed, 06 May 2026 15:53:24 +0200
parents d84f1fd10e64
children 380d2607d5c7
comparison
equal deleted inserted replaced
122:e39ca08b0609 123:4d96ace53ba1
4 # SPDX-License-Identifier: MIT 4 # SPDX-License-Identifier: MIT
5 # :- 5 # :-
6 6
7 from _tsetup import ALGLEXERFILENAME, ALGLEXERCLASS 7 from _tsetup import ALGLEXERFILENAME, ALGLEXERCLASS
8 8
9 import sys
10 import unittest 9 import unittest
11 10
12 import pygments 11 import pygments
13 import pygments.lexers 12 import pygments.lexers
14 import pygments.formatters 13 import pygments.formatters
319 ], 318 ],
320 pygments.lex("\\CLASS {\\n\\}}\n\\ENDCLASS {end class}", lexer)) 319 pygments.lex("\\CLASS {\\n\\}}\n\\ENDCLASS {end class}", lexer))
321 320
322 def test_remark_1(self): 321 def test_remark_1(self):
323 self.assertTokenStreamEqualComplete( 322 self.assertTokenStreamEqualComplete(
324 [("Comment.Single", "▷"), 323 [("Comment.Single", u"▷"),
325 ("Comment.Single", " the remark"), 324 ("Comment.Single", " the remark"),
326 ("Text.Whitespace", "\n"), 325 ("Text.Whitespace", "\n"),
327 ], 326 ],
328 pygments.lex("\\REMARK the remark\n", self.lexer)) 327 pygments.lex("\\REMARK the remark\n", self.lexer))
329 328
330 def test_remark_2(self): 329 def test_remark_2(self):
331 self.assertTokenStreamEqualComplete( 330 self.assertTokenStreamEqualComplete(
332 [("Comment.Single", "▷"), 331 [("Comment.Single", u"▷"),
333 ("Comment.Single", " the remark 1"), 332 ("Comment.Single", " the remark 1"),
334 ("Text.Whitespace", "\n"), 333 ("Text.Whitespace", "\n"),
335 ("Comment.Single", "▷"), 334 ("Comment.Single", u"▷"),
336 ("Comment.Single", " the remark 2"), 335 ("Comment.Single", " the remark 2"),
337 ("Text.Whitespace", "\n"), 336 ("Text.Whitespace", "\n"),
338 ], 337 ],
339 pygments.lex( 338 pygments.lex(
340 """\\remArk the remark 1 339 """\\remArk the remark 1
344 def test_remark_custom(self): 343 def test_remark_custom(self):
345 # With the APL comment symbol 344 # With the APL comment symbol
346 lexer = pygments.lexers.load_lexer_from_file( 345 lexer = pygments.lexers.load_lexer_from_file(
347 ALGLEXERFILENAME, ALGLEXERCLASS, remark=u"⍝") 346 ALGLEXERFILENAME, ALGLEXERCLASS, remark=u"⍝")
348 self.assertTokenStreamEqualComplete( 347 self.assertTokenStreamEqualComplete(
349 [("Comment.Single", "⍝"), # U+235D ⍝ APL FUNC. SYMBOL UP SHOE JOT 348 [("Comment.Single", u"⍝"), # U+235D ⍝ APL FUNC. SYMBOL UP SHOE JOT
350 ("Comment.Single", " another remark"), 349 ("Comment.Single", " another remark"),
351 ("Text.Whitespace", "\n"), 350 ("Text.Whitespace", "\n"),
352 ], 351 ],
353 pygments.lex("\\REMARK another remark\n", lexer)) 352 pygments.lex(u"\\REMARK another remark\n", lexer))
354 353
355 def test_remark_in_text(self): 354 def test_remark_in_text(self):
356 self.assertTokenStreamEqualComplete( 355 self.assertTokenStreamEqualComplete(
357 [("Text", "the text "), 356 [("Text", "the text "),
358 ("Comment.Single", "▷"), 357 ("Comment.Single", u"▷"),
359 ("Comment.Single", " the remark"), 358 ("Comment.Single", " the remark"),
360 ("Text.Whitespace", "\n"), 359 ("Text.Whitespace", "\n"),
361 ("Text", "the next text line"), 360 ("Text", "the next text line"),
362 ("Text.Whitespace", "\n"), 361 ("Text.Whitespace", "\n"),
363 ], 362 ],
443 ], 442 ],
444 pygments.lex(r"{}:(),;[]?@", self.lexer)) 443 pygments.lex(r"{}:(),;[]?@", self.lexer))
445 444
446 def test_block_empty(self): 445 def test_block_empty(self):
447 self.assertTokenStreamEqualComplete( 446 self.assertTokenStreamEqualComplete(
448 [("Text", "◆"), 447 [("Text", u"◆"),
449 ("Text.Whitespace", " "), 448 ("Text.Whitespace", " "),
450 ("Text.Whitespace", "\n"), 449 ("Text.Whitespace", "\n"),
451 ], 450 ],
452 pygments.lex(r"\block{}", self.lexer)) 451 pygments.lex(r"\block{}", self.lexer))
453 452
454 def test_block_with_text(self): 453 def test_block_with_text(self):
455 self.assertTokenStreamEqualComplete( 454 self.assertTokenStreamEqualComplete(
456 [("Text", "◆"), 455 [("Text", u"◆"),
457 ("Text.Whitespace", " "), 456 ("Text.Whitespace", " "),
458 ("Text", "a b c"), 457 ("Text", "a b c"),
459 ("Text.Whitespace", "\n"), 458 ("Text.Whitespace", "\n"),
460 ], 459 ],
461 pygments.lex(r"\block{\text{a b c}}", self.lexer)) 460 pygments.lex(r"\block{\text{a b c}}", self.lexer))
462 461
463 def test_block_with_escaped_text(self): 462 def test_block_with_escaped_text(self):
464 self.assertTokenStreamEqualComplete( 463 self.assertTokenStreamEqualComplete(
465 [("Text", "◆"), 464 [("Text", u"◆"),
466 ("Text.Whitespace", " "), 465 ("Text.Whitespace", " "),
467 ("Text", "\\"), 466 ("Text", "\\"),
468 ("Name.Entity", "text"), 467 ("Name.Entity", "text"),
469 ("Punctuation", "{"), 468 ("Punctuation", "{"),
470 ("Name.Entity", "a"), 469 ("Name.Entity", "a"),
477 ], 476 ],
478 pygments.lex(r"\block{\\text{a b c\}}", self.lexer)) 477 pygments.lex(r"\block{\\text{a b c\}}", self.lexer))
479 478
480 def test_block(self): 479 def test_block(self):
481 self.assertTokenStreamEqualComplete( 480 self.assertTokenStreamEqualComplete(
482 [("Text", "◆"), 481 [("Text", u"◆"),
483 ("Text.Whitespace", " "), 482 ("Text.Whitespace", " "),
484 ("Name.Entity", "a"), 483 ("Name.Entity", "a"),
485 ("Text", " "), 484 ("Text", " "),
486 ("Number.Float", "1.2"), 485 ("Number.Float", "1.2"),
487 ("Text", " "), 486 ("Text", " "),
498 ], 497 ],
499 pygments.lex(r"\state{a 1.2 {x in X\} c}", self.lexer)) 498 pygments.lex(r"\state{a 1.2 {x in X\} c}", self.lexer))
500 499
501 def test_tstate_empty(self): 500 def test_tstate_empty(self):
502 self.assertTokenStreamEqualComplete( 501 self.assertTokenStreamEqualComplete(
503 [("Text", "▪"), 502 [("Text", u"▪"),
504 ("Text.Whitespace", " "), 503 ("Text.Whitespace", " "),
505 ("Text.Whitespace", "\n"), 504 ("Text.Whitespace", "\n"),
506 ], 505 ],
507 pygments.lex(r"\tstate{}", self.lexer)) 506 pygments.lex(r"\tstate{}", self.lexer))
508 507
509 def test_tstate_with_expr(self): 508 def test_tstate_with_expr(self):
510 self.assertTokenStreamEqualComplete( 509 self.assertTokenStreamEqualComplete(
511 [("Text", "▪"), 510 [("Text", u"▪"),
512 ("Text.Whitespace", " "), 511 ("Text.Whitespace", " "),
513 ("Text", "a 1.2 "), 512 ("Text", "a 1.2 "),
514 ("Name.Entity", "x"), 513 ("Name.Entity", "x"),
515 ("Text", " "), 514 ("Text", " "),
516 ("Operator.Word", "in"), 515 ("Operator.Word", "in"),
522 ], 521 ],
523 pygments.lex(r"\tstate{a 1.2 \expr{x in X\}} c}", self.lexer)) 522 pygments.lex(r"\tstate{a 1.2 \expr{x in X\}} c}", self.lexer))
524 523
525 def test_tstate_with_escaped_expr(self): 524 def test_tstate_with_escaped_expr(self):
526 self.assertTokenStreamEqualComplete( 525 self.assertTokenStreamEqualComplete(
527 [("Text", "▪"), 526 [("Text", u"▪"),
528 ("Text.Whitespace", " "), 527 ("Text.Whitespace", " "),
529 ("Text", "a 1.2 "), 528 ("Text", "a 1.2 "),
530 ("Text", "\\"), 529 ("Text", "\\"),
531 ("Text", "expr{x in X"), 530 ("Text", "expr{x in X"),
532 ("Text", "}"), 531 ("Text", "}"),
626 625
627 def test_explicit_tokentype_with_remark(self): 626 def test_explicit_tokentype_with_remark(self):
628 self.assertTokenStreamEqualComplete( 627 self.assertTokenStreamEqualComplete(
629 [("Operator", u"∈ ∌"), 628 [("Operator", u"∈ ∌"),
630 ("Text", " "), 629 ("Text", " "),
631 ("Comment.Single", "▷"), 630 ("Comment.Single", u"▷"),
632 ("Comment.Single", u" ∈ ∌ as (ordinary) operators"), 631 ("Comment.Single", u" ∈ ∌ as (ordinary) operators"),
633 ("Text.Whitespace", "\n"), 632 ("Text.Whitespace", "\n"),
634 ], 633 ],
635 pygments.lex( 634 pygments.lex(
636 u"""\\ttx-o<∈ ∌> \\rem ∈ ∌ as (ordinary) operators""", 635 u"""\\ttx-o<∈ ∌> \\rem ∈ ∌ as (ordinary) operators""",
638 637
639 def test_explicit_tokentype_with_remark_2(self): 638 def test_explicit_tokentype_with_remark_2(self):
640 self.assertTokenStreamEqualComplete( 639 self.assertTokenStreamEqualComplete(
641 [("Operator", "new_operator"), 640 [("Operator", "new_operator"),
642 ("Text", " "), 641 ("Text", " "),
643 ("Comment.Single", "▷"), 642 ("Comment.Single", u"▷"),
644 ("Comment.Single", " a (synthesized) operator"), 643 ("Comment.Single", " a (synthesized) operator"),
645 ("Text.Whitespace", "\n"), 644 ("Text.Whitespace", "\n"),
646 ], 645 ],
647 pygments.lex( 646 pygments.lex(
648 r"""\ttx-o<new_operator> \rem a (synthesized) operator""", 647 r"""\ttx-o<new_operator> \rem a (synthesized) operator""",
671 ("Punctuation", ","), 670 ("Punctuation", ","),
672 ("Text", " "), 671 ("Text", " "),
673 ("Name.Entity", "p2"), 672 ("Name.Entity", "p2"),
674 ("Punctuation", ")"), 673 ("Punctuation", ")"),
675 ("Text", " "), 674 ("Text", " "),
676 ("Comment.Single", "▷"), 675 ("Comment.Single", u"▷"),
677 ("Comment.Single", " (Python) decorator"), 676 ("Comment.Single", " (Python) decorator"),
678 ("Text.Whitespace", "\n"), 677 ("Text.Whitespace", "\n"),
679 ], 678 ],
680 pygments.lex( 679 pygments.lex(
681 r"""\ttx-nd<a_Decorator>(p1, p2) \rem (Python) decorator""", 680 r"""\ttx-nd<a_Decorator>(p1, p2) \rem (Python) decorator""",
689 ("Punctuation", ","), 688 ("Punctuation", ","),
690 ("Text", " "), 689 ("Text", " "),
691 ("Name.Entity", "p2"), 690 ("Name.Entity", "p2"),
692 ("Punctuation", ")"), 691 ("Punctuation", ")"),
693 ("Text", " "), 692 ("Text", " "),
694 ("Comment.Single", "▷"), 693 ("Comment.Single", u"▷"),
695 ("Comment.Single", " (Python) annotation"), 694 ("Comment.Single", " (Python) annotation"),
696 ("Text.Whitespace", "\n"), 695 ("Text.Whitespace", "\n"),
697 ], 696 ],
698 pygments.lex( 697 pygments.lex(
699 r"""\ttx-nd[a_Decorator](p1, p2) \rem (Python) annotation""", 698 r"""\ttx-nd[a_Decorator](p1, p2) \rem (Python) annotation""",
755 ("Operator", "~"), 754 ("Operator", "~"),
756 ("Text.Whitespace", "\n"), 755 ("Text.Whitespace", "\n"),
757 ], 756 ],
758 pygments.lex("=!&< >+-*/%|~", self.lexer)) 757 pygments.lex("=!&< >+-*/%|~", self.lexer))
759 758
760 @unittest.skipIf(sys.version_info[0] <= 2, "Unicode issues on Python 2")
761 def test_ascii_math_operator_with_replacements(self): 759 def test_ascii_math_operator_with_replacements(self):
762 self.assertTokenStreamEqualComplete( 760 self.assertTokenStreamEqualComplete(
763 [("Operator", u"⇔"), 761 [("Operator", u"⇔"),
764 ("Text", " "), 762 ("Text", " "),
765 ("Operator", u"⟷"), 763 ("Operator", u"⟷"),
888 886
889 def test_gets_default(self): 887 def test_gets_default(self):
890 self.assertTokenStreamEqualComplete( 888 self.assertTokenStreamEqualComplete(
891 [("Name.Entity", "a"), 889 [("Name.Entity", "a"),
892 ("Text", " "), 890 ("Text", " "),
893 ("Operator", "⟵"), # U+27F5 (Supplemental Arrows-A) 891 ("Operator", u"⟵"), # U+27F5 (Supplemental Arrows-A)
894 ("Text", " "), 892 ("Text", " "),
895 ("Number.Integer", "2"), 893 ("Number.Integer", "2"),
896 ("Text.Whitespace", "\n"), 894 ("Text.Whitespace", "\n"),
897 ], 895 ],
898 pygments.lex(r"a \gets 2", self.lexer)) 896 pygments.lex(r"a \gets 2", self.lexer))