From 91a5f3e10300fd84db26690095329592de0942d7 Mon Sep 17 00:00:00 2001 From: Kartik Agaram Date: Fri, 11 Sep 2020 00:59:56 -0700 Subject: 6774 --- html/405screen.mu.html | 1352 ++++++++++++++++++++++++++++-------------------- 1 file changed, 795 insertions(+), 557 deletions(-) (limited to 'html/405screen.mu.html') diff --git a/html/405screen.mu.html b/html/405screen.mu.html index 566792ce..e252bb0d 100644 --- a/html/405screen.mu.html +++ b/html/405screen.mu.html @@ -675,572 +675,810 @@ if ('onhashchange' in window) { 615 var done?/eax: boolean <- stream-empty? e-addr 616 compare done?, 0 617 break-if-!= - 618 var g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 619 var g2/ebx: int <- copy g + 618 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx + 619 var g/ebx: grapheme <- copy _g 620 var expected-grapheme/eax: grapheme <- read-grapheme e-addr - 621 var expected-grapheme2/eax: int <- copy expected-grapheme - 622 # compare graphemes - 623 $check-screen-row-from:compare-graphemes: { - 624 # if expected-grapheme is space, null grapheme is also ok - 625 { - 626 compare expected-grapheme2, 0x20 - 627 break-if-!= - 628 compare g2, 0 - 629 break-if-= $check-screen-row-from:compare-graphemes - 630 } - 631 check-ints-equal g2, expected-grapheme2, msg - 632 } - 633 idx <- increment - 634 loop - 635 } - 636 } - 637 - 638 # various variants by screen-cell attribute; spaces in the 'expected' data should not match the attribute - 639 - 640 fn check-screen-row-in-color screen: (addr screen), fg: int, row-idx: int, expected: (addr array byte), msg: (addr array byte) { - 641 check-screen-row-in-color-from screen, fg, row-idx, 1, expected, msg - 642 } - 643 - 644 fn check-screen-row-in-color-from screen-on-stack: (addr screen), fg: int, row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { - 645 var screen/esi: (addr screen) <- copy screen-on-stack - 646 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx - 647 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme - 648 var e: (stream byte 0x100) - 649 var e-addr/edx: (addr stream byte) <- address e - 650 write e-addr, expected - 651 { - 652 var done?/eax: boolean <- stream-empty? e-addr - 653 compare done?, 0 - 654 break-if-!= - 655 var g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 656 var g2/ebx: int <- copy g - 657 var expected-grapheme/eax: grapheme <- read-grapheme e-addr - 658 var expected-grapheme2/edx: int <- copy expected-grapheme - 659 # compare graphemes - 660 $check-screen-row-in-color-from:compare-graphemes: { - 661 # if expected-grapheme is space, null grapheme is also ok - 662 { - 663 compare expected-grapheme2, 0x20 - 664 break-if-!= - 665 compare g2, 0 - 666 break-if-= $check-screen-row-in-color-from:compare-graphemes - 667 } - 668 # if expected-grapheme is space, a different color is ok - 669 { - 670 compare expected-grapheme2, 0x20 - 671 break-if-!= - 672 var color/eax: int <- screen-color-at-idx screen, idx - 673 compare color, fg - 674 break-if-!= $check-screen-row-in-color-from:compare-graphemes - 675 } - 676 check-ints-equal g2, expected-grapheme2, msg - 677 var color/eax: int <- screen-color-at-idx screen, idx - 678 check-ints-equal color, fg, msg - 679 } - 680 idx <- increment - 681 loop - 682 } - 683 } - 684 - 685 # background color is visible even for spaces, so 'expected' behaves as an array of booleans. - 686 # non-space = given background must match; space = background must not match - 687 fn check-screen-row-in-background-color screen: (addr screen), bg: int, row-idx: int, expected: (addr array byte), msg: (addr array byte) { - 688 check-screen-row-in-background-color-from screen, bg, row-idx, 1, expected, msg - 689 } - 690 - 691 fn check-screen-row-in-background-color-from screen-on-stack: (addr screen), bg: int, row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { - 692 var screen/esi: (addr screen) <- copy screen-on-stack - 693 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx - 694 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme - 695 var e: (stream byte 0x100) - 696 var e-addr/edx: (addr stream byte) <- address e - 697 write e-addr, expected - 698 { - 699 var done?/eax: boolean <- stream-empty? e-addr - 700 compare done?, 0 - 701 break-if-!= - 702 var g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 703 var g2/ebx: int <- copy g - 704 var expected-grapheme/eax: grapheme <- read-grapheme e-addr - 705 var expected-grapheme2/edx: int <- copy expected-grapheme - 706 # compare graphemes - 707 $check-screen-row-in-background-color-from:compare-graphemes: { - 708 # if expected-grapheme is space, null grapheme is also ok - 709 { - 710 compare expected-grapheme2, 0x20 - 711 break-if-!= - 712 compare g2, 0 - 713 break-if-= $check-screen-row-in-background-color-from:compare-graphemes - 714 } - 715 # if expected-grapheme is space, a different color is ok - 716 { - 717 compare expected-grapheme2, 0x20 - 718 break-if-!= - 719 var color/eax: int <- screen-background-color-at-idx screen, idx - 720 compare color, bg - 721 break-if-!= $check-screen-row-in-background-color-from:compare-graphemes - 722 } - 723 check-ints-equal g2, expected-grapheme2, msg - 724 var color/eax: int <- screen-background-color-at-idx screen, idx - 725 check-ints-equal color, bg, msg - 726 } - 727 idx <- increment - 728 loop - 729 } - 730 } - 731 - 732 fn check-screen-row-in-bold screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { - 733 check-screen-row-in-bold-from screen, row-idx, 1, expected, msg - 734 } - 735 - 736 fn check-screen-row-in-bold-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { - 737 var screen/esi: (addr screen) <- copy screen-on-stack - 738 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx - 739 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme - 740 var e: (stream byte 0x100) - 741 var e-addr/edx: (addr stream byte) <- address e - 742 write e-addr, expected - 743 { - 744 var done?/eax: boolean <- stream-empty? e-addr - 745 compare done?, 0 - 746 break-if-!= - 747 var g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 748 var g2/ebx: int <- copy g - 749 var expected-grapheme/eax: grapheme <- read-grapheme e-addr - 750 var expected-grapheme2/edx: int <- copy expected-grapheme - 751 # compare graphemes - 752 $check-screen-row-in-bold-from:compare-graphemes: { - 753 # if expected-grapheme is space, null grapheme is also ok - 754 { - 755 compare expected-grapheme2, 0x20 - 756 break-if-!= - 757 compare g2, 0 - 758 break-if-= $check-screen-row-in-bold-from:compare-graphemes - 759 } - 760 # if expected-grapheme is space, non-bold is ok - 761 { - 762 compare expected-grapheme2, 0x20 - 763 break-if-!= - 764 var bold?/eax: boolean <- screen-bold-at-idx? screen, idx - 765 compare bold?, 1 - 766 break-if-!= $check-screen-row-in-bold-from:compare-graphemes - 767 } - 768 check-ints-equal g2, expected-grapheme2, msg - 769 var bold?/eax: boolean <- screen-bold-at-idx? screen, idx - 770 var bold/eax: int <- copy bold? - 771 check-ints-equal bold, 1, msg - 772 } - 773 idx <- increment - 774 loop - 775 } - 776 } - 777 - 778 fn check-screen-row-in-underline screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { - 779 check-screen-row-in-underline-from screen, row-idx, 1, expected, msg - 780 } - 781 - 782 fn check-screen-row-in-underline-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { - 783 var screen/esi: (addr screen) <- copy screen-on-stack - 784 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx - 785 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme - 786 var e: (stream byte 0x100) - 787 var e-addr/edx: (addr stream byte) <- address e - 788 write e-addr, expected - 789 { - 790 var done?/eax: boolean <- stream-empty? e-addr - 791 compare done?, 0 - 792 break-if-!= - 793 var g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 794 var g2/ebx: int <- copy g - 795 var expected-grapheme/eax: grapheme <- read-grapheme e-addr - 796 var expected-grapheme2/edx: int <- copy expected-grapheme - 797 # compare graphemes - 798 $check-screen-row-in-underline-from:compare-graphemes: { - 799 # if expected-grapheme is space, null grapheme is also ok - 800 { - 801 compare expected-grapheme2, 0x20 - 802 break-if-!= - 803 compare g2, 0 - 804 break-if-= $check-screen-row-in-underline-from:compare-graphemes - 805 } - 806 # if expected-grapheme is space, non-underline is ok - 807 { - 808 compare expected-grapheme2, 0x20 - 809 break-if-!= - 810 var underline?/eax: boolean <- screen-underline-at-idx? screen, idx - 811 compare underline?, 1 - 812 break-if-!= $check-screen-row-in-underline-from:compare-graphemes - 813 } - 814 check-ints-equal g2, expected-grapheme2, msg - 815 var underline?/eax: boolean <- screen-underline-at-idx? screen, idx - 816 var underline/eax: int <- copy underline? - 817 check-ints-equal underline, 1, msg - 818 } - 819 idx <- increment - 820 loop - 821 } - 822 } - 823 - 824 fn check-screen-row-in-reverse screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { - 825 check-screen-row-in-reverse-from screen, row-idx, 1, expected, msg - 826 } - 827 - 828 fn check-screen-row-in-reverse-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { - 829 var screen/esi: (addr screen) <- copy screen-on-stack - 830 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx - 831 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme - 832 var e: (stream byte 0x100) - 833 var e-addr/edx: (addr stream byte) <- address e - 834 write e-addr, expected - 835 { - 836 var done?/eax: boolean <- stream-empty? e-addr - 837 compare done?, 0 - 838 break-if-!= - 839 var g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 840 var g2/ebx: int <- copy g - 841 var expected-grapheme/eax: grapheme <- read-grapheme e-addr - 842 var expected-grapheme2/edx: int <- copy expected-grapheme - 843 # compare graphemes - 844 $check-screen-row-in-reverse-from:compare-graphemes: { - 845 # if expected-grapheme is space, null grapheme is also ok - 846 { - 847 compare expected-grapheme2, 0x20 - 848 break-if-!= - 849 compare g2, 0 - 850 break-if-= $check-screen-row-in-reverse-from:compare-graphemes - 851 } - 852 # if expected-grapheme is space, non-reverse is ok - 853 { - 854 compare expected-grapheme2, 0x20 - 855 break-if-!= - 856 var reverse?/eax: boolean <- screen-reverse-at-idx? screen, idx - 857 compare reverse?, 1 - 858 break-if-!= $check-screen-row-in-reverse-from:compare-graphemes - 859 } - 860 check-ints-equal g2, expected-grapheme2, msg - 861 var reverse?/eax: boolean <- screen-reverse-at-idx? screen, idx - 862 var reverse/eax: int <- copy reverse? - 863 check-ints-equal reverse, 1, msg - 864 } - 865 idx <- increment - 866 loop - 867 } - 868 } - 869 - 870 fn check-screen-row-in-blinking screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { - 871 check-screen-row-in-blinking-from screen, row-idx, 1, expected, msg - 872 } - 873 - 874 fn check-screen-row-in-blinking-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { - 875 var screen/esi: (addr screen) <- copy screen-on-stack - 876 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx - 877 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme - 878 var e: (stream byte 0x100) - 879 var e-addr/edx: (addr stream byte) <- address e - 880 write e-addr, expected - 881 { - 882 var done?/eax: boolean <- stream-empty? e-addr - 883 compare done?, 0 - 884 break-if-!= - 885 var g/eax: grapheme <- screen-grapheme-at-idx screen, idx - 886 var g2/ebx: int <- copy g - 887 var expected-grapheme/eax: grapheme <- read-grapheme e-addr - 888 var expected-grapheme2/edx: int <- copy expected-grapheme - 889 # compare graphemes - 890 $check-screen-row-in-blinking-from:compare-graphemes: { - 891 # if expected-grapheme is space, null grapheme is also ok - 892 { - 893 compare expected-grapheme2, 0x20 - 894 break-if-!= - 895 compare g2, 0 - 896 break-if-= $check-screen-row-in-blinking-from:compare-graphemes - 897 } - 898 # if expected-grapheme is space, non-blinking is ok - 899 { - 900 compare expected-grapheme2, 0x20 - 901 break-if-!= - 902 var blinking?/eax: boolean <- screen-blink-at-idx? screen, idx - 903 compare blinking?, 1 - 904 break-if-!= $check-screen-row-in-blinking-from:compare-graphemes - 905 } - 906 check-ints-equal g2, expected-grapheme2, msg - 907 var blinking?/eax: boolean <- screen-blink-at-idx? screen, idx - 908 var blinking/eax: int <- copy blinking? - 909 check-ints-equal blinking, 1, msg - 910 } - 911 idx <- increment - 912 loop - 913 } - 914 } - 915 - 916 fn test-print-single-grapheme { - 917 var screen-on-stack: screen - 918 var screen/esi: (addr screen) <- address screen-on-stack - 919 initialize-screen screen, 5, 4 - 920 var c/eax: grapheme <- copy 0x61 # 'a' - 921 print-grapheme screen, c - 922 check-screen-row screen, 1, "a", "F - test-print-single-grapheme" # top-left corner of the screen - 923 } - 924 - 925 fn test-print-multiple-graphemes { - 926 var screen-on-stack: screen - 927 var screen/esi: (addr screen) <- address screen-on-stack - 928 initialize-screen screen, 5, 4 - 929 print-string screen, "Hello, 世界" - 930 check-screen-row screen, 1, "Hello, 世界", "F - test-print-multiple-graphemes" - 931 } - 932 - 933 fn test-move-cursor { - 934 var screen-on-stack: screen - 935 var screen/esi: (addr screen) <- address screen-on-stack - 936 initialize-screen screen, 5, 4 - 937 move-cursor screen, 1, 4 - 938 var c/eax: grapheme <- copy 0x61 # 'a' - 939 print-grapheme screen, c - 940 check-screen-row screen, 1, " a", "F - test-move-cursor" # top row - 941 } - 942 - 943 fn test-move-cursor-zeroes { - 944 var screen-on-stack: screen - 945 var screen/esi: (addr screen) <- address screen-on-stack - 946 initialize-screen screen, 5, 4 - 947 move-cursor screen, 0, 0 - 948 var c/eax: grapheme <- copy 0x61 # 'a' - 949 print-grapheme screen, c - 950 check-screen-row screen, 1, "a", "F - test-move-cursor-zeroes" # top-left corner of the screen - 951 } - 952 - 953 fn test-move-cursor-zero-row { - 954 var screen-on-stack: screen - 955 var screen/esi: (addr screen) <- address screen-on-stack - 956 initialize-screen screen, 5, 4 - 957 move-cursor screen, 0, 2 - 958 var c/eax: grapheme <- copy 0x61 # 'a' - 959 print-grapheme screen, c - 960 check-screen-row screen, 1, " a", "F - test-move-cursor-zero-row" # top row - 961 } - 962 - 963 fn test-move-cursor-zero-column { - 964 var screen-on-stack: screen - 965 var screen/esi: (addr screen) <- address screen-on-stack - 966 initialize-screen screen, 5, 4 - 967 move-cursor screen, 4, 0 - 968 var c/eax: grapheme <- copy 0x61 # 'a' - 969 print-grapheme screen, c - 970 check-screen-row screen, 4, "a", "F - test-move-cursor-zero-column" - 971 } - 972 - 973 fn test-move-cursor-negative-row { - 974 var screen-on-stack: screen - 975 var screen/esi: (addr screen) <- address screen-on-stack - 976 initialize-screen screen, 5, 3 - 977 move-cursor screen, -1, 2 # row -1 - 978 var c/eax: grapheme <- copy 0x61 # 'a' - 979 print-grapheme screen, c - 980 # no move - 981 check-screen-row screen, 1, "a", "F - test-move-cursor-negative-row" - 982 } - 983 - 984 fn test-move-cursor-negative-column { - 985 var screen-on-stack: screen - 986 var screen/esi: (addr screen) <- address screen-on-stack - 987 initialize-screen screen, 5, 3 - 988 move-cursor screen, 2, -1 # column -1 - 989 var c/eax: grapheme <- copy 0x61 # 'a' - 990 print-grapheme screen, c - 991 # no move - 992 check-screen-row screen, 1, "a", "F - test-move-cursor-negative-column" + 621 # compare graphemes + 622 $check-screen-row-from:compare-graphemes: { + 623 # if expected-grapheme is space, null grapheme is also ok + 624 { + 625 compare expected-grapheme, 0x20 + 626 break-if-!= + 627 compare g, 0 + 628 break-if-= $check-screen-row-from:compare-graphemes + 629 } + 630 # if (g == expected-grapheme) print "." + 631 compare g, expected-grapheme + 632 { + 633 break-if-!= + 634 print-string-to-real-screen "." + 635 break $check-screen-row-from:compare-graphemes + 636 } + 637 # otherwise print an error + 638 print-string-to-real-screen msg + 639 print-string-to-real-screen ": expected '" + 640 print-grapheme-to-real-screen expected-grapheme + 641 print-string-to-real-screen "' at (" + 642 print-int32-hex-to-real-screen row-idx + 643 print-string-to-real-screen ", " + 644 print-int32-hex-to-real-screen col-idx + 645 print-string-to-real-screen ") but observed '" + 646 print-grapheme-to-real-screen g + 647 print-string-to-real-screen "'\n" + 648 } + 649 idx <- increment + 650 increment col-idx + 651 loop + 652 } + 653 } + 654 + 655 # various variants by screen-cell attribute; spaces in the 'expected' data should not match the attribute + 656 + 657 fn check-screen-row-in-color screen: (addr screen), fg: int, row-idx: int, expected: (addr array byte), msg: (addr array byte) { + 658 check-screen-row-in-color-from screen, fg, row-idx, 1, expected, msg + 659 } + 660 + 661 fn check-screen-row-in-color-from screen-on-stack: (addr screen), fg: int, row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { + 662 var screen/esi: (addr screen) <- copy screen-on-stack + 663 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx + 664 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme + 665 var e: (stream byte 0x100) + 666 var e-addr/edx: (addr stream byte) <- address e + 667 write e-addr, expected + 668 { + 669 var done?/eax: boolean <- stream-empty? e-addr + 670 compare done?, 0 + 671 break-if-!= + 672 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx + 673 var g/ebx: grapheme <- copy _g + 674 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr + 675 var expected-grapheme/edi: grapheme <- copy _expected-grapheme + 676 $check-screen-row-in-color-from:compare-cells: { + 677 # if expected-grapheme is space, null grapheme is also ok + 678 { + 679 compare expected-grapheme, 0x20 + 680 break-if-!= + 681 compare g, 0 + 682 break-if-= $check-screen-row-in-color-from:compare-cells + 683 } + 684 # if expected-grapheme is space, a different color is ok + 685 { + 686 compare expected-grapheme, 0x20 + 687 break-if-!= + 688 var color/eax: int <- screen-color-at-idx screen, idx + 689 compare color, fg + 690 break-if-!= $check-screen-row-in-color-from:compare-cells + 691 } + 692 # compare graphemes + 693 $check-screen-row-in-color-from:compare-graphemes: { + 694 # if (g == expected-grapheme) print "." + 695 compare g, expected-grapheme + 696 { + 697 break-if-!= + 698 print-string-to-real-screen "." + 699 break $check-screen-row-in-color-from:compare-graphemes + 700 } + 701 # otherwise print an error + 702 print-string-to-real-screen msg + 703 print-string-to-real-screen ": expected '" + 704 print-grapheme-to-real-screen expected-grapheme + 705 print-string-to-real-screen "' at (" + 706 print-int32-hex-to-real-screen row-idx + 707 print-string-to-real-screen ", " + 708 print-int32-hex-to-real-screen col-idx + 709 print-string-to-real-screen ") but observed '" + 710 print-grapheme-to-real-screen g + 711 print-string-to-real-screen "'\n" + 712 } + 713 $check-screen-row-in-color-from:compare-colors: { + 714 var color/eax: int <- screen-color-at-idx screen, idx + 715 compare fg, color + 716 { + 717 break-if-!= + 718 print-string-to-real-screen "." + 719 break $check-screen-row-in-color-from:compare-colors + 720 } + 721 # otherwise print an error + 722 print-string-to-real-screen msg + 723 print-string-to-real-screen ": expected '" + 724 print-grapheme-to-real-screen expected-grapheme + 725 print-string-to-real-screen "' at (" + 726 print-int32-hex-to-real-screen row-idx + 727 print-string-to-real-screen ", " + 728 print-int32-hex-to-real-screen col-idx + 729 print-string-to-real-screen ") in color " + 730 print-int32-hex-to-real-screen fg + 731 print-string-to-real-screen " but observed color " + 732 print-int32-hex-to-real-screen color + 733 print-string-to-real-screen "\n" + 734 } + 735 } + 736 idx <- increment + 737 increment col-idx + 738 loop + 739 } + 740 } + 741 + 742 # background color is visible even for spaces, so 'expected' behaves as an array of booleans. + 743 # non-space = given background must match; space = background must not match + 744 fn check-screen-row-in-background-color screen: (addr screen), bg: int, row-idx: int, expected: (addr array byte), msg: (addr array byte) { + 745 check-screen-row-in-background-color-from screen, bg, row-idx, 1, expected, msg + 746 } + 747 + 748 fn check-screen-row-in-background-color-from screen-on-stack: (addr screen), bg: int, row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { + 749 var screen/esi: (addr screen) <- copy screen-on-stack + 750 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx + 751 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme + 752 var e: (stream byte 0x100) + 753 var e-addr/edx: (addr stream byte) <- address e + 754 write e-addr, expected + 755 { + 756 var done?/eax: boolean <- stream-empty? e-addr + 757 compare done?, 0 + 758 break-if-!= + 759 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx + 760 var g/ebx: grapheme <- copy _g + 761 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr + 762 var expected-grapheme/edx: grapheme <- copy _expected-grapheme + 763 $check-screen-row-in-background-color-from:compare-cells: { + 764 # if expected-grapheme is space, null grapheme is also ok + 765 { + 766 compare expected-grapheme, 0x20 + 767 break-if-!= + 768 compare g, 0 + 769 break-if-= $check-screen-row-in-background-color-from:compare-cells + 770 } + 771 # if expected-grapheme is space, a different color is ok + 772 { + 773 compare expected-grapheme, 0x20 + 774 break-if-!= + 775 var color/eax: int <- screen-background-color-at-idx screen, idx + 776 compare color, bg + 777 break-if-!= $check-screen-row-in-background-color-from:compare-cells + 778 } + 779 # compare graphemes + 780 $check-screen-row-in-background-color-from:compare-graphemes: { + 781 # if (g == expected-grapheme) print "." + 782 compare g, expected-grapheme + 783 { + 784 break-if-!= + 785 print-string-to-real-screen "." + 786 break $check-screen-row-in-background-color-from:compare-graphemes + 787 } + 788 # otherwise print an error + 789 print-string-to-real-screen msg + 790 print-string-to-real-screen ": expected '" + 791 print-grapheme-to-real-screen expected-grapheme + 792 print-string-to-real-screen "' at (" + 793 print-int32-hex-to-real-screen row-idx + 794 print-string-to-real-screen ", " + 795 print-int32-hex-to-real-screen col-idx + 796 print-string-to-real-screen ") but observed '" + 797 print-grapheme-to-real-screen g + 798 print-string-to-real-screen "'\n" + 799 } + 800 $check-screen-row-in-background-color-from:compare-colors: { + 801 var color/eax: int <- screen-background-color-at-idx screen, idx + 802 compare bg, color + 803 { + 804 break-if-!= + 805 print-string-to-real-screen "." + 806 break $check-screen-row-in-background-color-from:compare-colors + 807 } + 808 # otherwise print an error + 809 print-string-to-real-screen msg + 810 print-string-to-real-screen ": expected '" + 811 print-grapheme-to-real-screen expected-grapheme + 812 print-string-to-real-screen "' at (" + 813 print-int32-hex-to-real-screen row-idx + 814 print-string-to-real-screen ", " + 815 print-int32-hex-to-real-screen col-idx + 816 print-string-to-real-screen ") in background color " + 817 print-int32-hex-to-real-screen bg + 818 print-string-to-real-screen " but observed color " + 819 print-int32-hex-to-real-screen color + 820 print-string-to-real-screen "\n" + 821 } + 822 } + 823 idx <- increment + 824 increment col-idx + 825 loop + 826 } + 827 } + 828 + 829 fn check-screen-row-in-bold screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { + 830 check-screen-row-in-bold-from screen, row-idx, 1, expected, msg + 831 } + 832 + 833 fn check-screen-row-in-bold-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { + 834 var screen/esi: (addr screen) <- copy screen-on-stack + 835 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx + 836 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme + 837 var e: (stream byte 0x100) + 838 var e-addr/edx: (addr stream byte) <- address e + 839 write e-addr, expected + 840 { + 841 var done?/eax: boolean <- stream-empty? e-addr + 842 compare done?, 0 + 843 break-if-!= + 844 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx + 845 var g/ebx: grapheme <- copy _g + 846 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr + 847 var expected-grapheme/edx: grapheme <- copy _expected-grapheme + 848 $check-screen-row-in-bold-from:compare-cells: { + 849 # if expected-grapheme is space, null grapheme is also ok + 850 { + 851 compare expected-grapheme, 0x20 + 852 break-if-!= + 853 compare g, 0 + 854 break-if-= $check-screen-row-in-bold-from:compare-cells + 855 } + 856 # if expected-grapheme is space, non-bold is ok + 857 { + 858 compare expected-grapheme, 0x20 + 859 break-if-!= + 860 var bold?/eax: boolean <- screen-bold-at-idx? screen, idx + 861 compare bold?, 1 + 862 break-if-!= $check-screen-row-in-bold-from:compare-cells + 863 } + 864 # compare graphemes + 865 $check-screen-row-in-bold-from:compare-graphemes: { + 866 # if (g == expected-grapheme) print "." + 867 compare g, expected-grapheme + 868 { + 869 break-if-!= + 870 print-string-to-real-screen "." + 871 break $check-screen-row-in-bold-from:compare-graphemes + 872 } + 873 # otherwise print an error + 874 print-string-to-real-screen msg + 875 print-string-to-real-screen ": expected '" + 876 print-grapheme-to-real-screen expected-grapheme + 877 print-string-to-real-screen "' at (" + 878 print-int32-hex-to-real-screen row-idx + 879 print-string-to-real-screen ", " + 880 print-int32-hex-to-real-screen col-idx + 881 print-string-to-real-screen ") but observed '" + 882 print-grapheme-to-real-screen g + 883 print-string-to-real-screen "'\n" + 884 } + 885 $check-screen-row-in-bold-from:compare-bold: { + 886 var bold?/eax: boolean <- screen-bold-at-idx? screen, idx + 887 compare bold?, 1 + 888 { + 889 break-if-!= + 890 print-string-to-real-screen "." + 891 break $check-screen-row-in-bold-from:compare-bold + 892 } + 893 # otherwise print an error + 894 print-string-to-real-screen msg + 895 print-string-to-real-screen ": expected '" + 896 print-grapheme-to-real-screen expected-grapheme + 897 print-string-to-real-screen "' at (" + 898 print-int32-hex-to-real-screen row-idx + 899 print-string-to-real-screen ", " + 900 print-int32-hex-to-real-screen col-idx + 901 print-string-to-real-screen ") to be in bold\n" + 902 } + 903 } + 904 idx <- increment + 905 increment col-idx + 906 loop + 907 } + 908 } + 909 + 910 fn check-screen-row-in-underline screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { + 911 check-screen-row-in-underline-from screen, row-idx, 1, expected, msg + 912 } + 913 + 914 fn check-screen-row-in-underline-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { + 915 var screen/esi: (addr screen) <- copy screen-on-stack + 916 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx + 917 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme + 918 var e: (stream byte 0x100) + 919 var e-addr/edx: (addr stream byte) <- address e + 920 write e-addr, expected + 921 { + 922 var done?/eax: boolean <- stream-empty? e-addr + 923 compare done?, 0 + 924 break-if-!= + 925 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx + 926 var g/ebx: grapheme <- copy _g + 927 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr + 928 var expected-grapheme/edx: grapheme <- copy _expected-grapheme + 929 $check-screen-row-in-underline-from:compare-cells: { + 930 # if expected-grapheme is space, null grapheme is also ok + 931 { + 932 compare expected-grapheme, 0x20 + 933 break-if-!= + 934 compare g, 0 + 935 break-if-= $check-screen-row-in-underline-from:compare-cells + 936 } + 937 # if expected-grapheme is space, non-underline is ok + 938 { + 939 compare expected-grapheme, 0x20 + 940 break-if-!= + 941 var underline?/eax: boolean <- screen-underline-at-idx? screen, idx + 942 compare underline?, 1 + 943 break-if-!= $check-screen-row-in-underline-from:compare-cells + 944 } + 945 # compare graphemes + 946 $check-screen-row-in-underline-from:compare-graphemes: { + 947 # if (g == expected-grapheme) print "." + 948 compare g, expected-grapheme + 949 { + 950 break-if-!= + 951 print-string-to-real-screen "." + 952 break $check-screen-row-in-underline-from:compare-graphemes + 953 } + 954 # otherwise print an error + 955 print-string-to-real-screen msg + 956 print-string-to-real-screen ": expected '" + 957 print-grapheme-to-real-screen expected-grapheme + 958 print-string-to-real-screen "' at (" + 959 print-int32-hex-to-real-screen row-idx + 960 print-string-to-real-screen ", " + 961 print-int32-hex-to-real-screen col-idx + 962 print-string-to-real-screen ") but observed '" + 963 print-grapheme-to-real-screen g + 964 print-string-to-real-screen "'\n" + 965 } + 966 $check-screen-row-in-underline-from:compare-underline: { + 967 var underline?/eax: boolean <- screen-underline-at-idx? screen, idx + 968 compare underline?, 1 + 969 { + 970 break-if-!= + 971 print-string-to-real-screen "." + 972 break $check-screen-row-in-underline-from:compare-underline + 973 } + 974 # otherwise print an error + 975 print-string-to-real-screen msg + 976 print-string-to-real-screen ": expected '" + 977 print-grapheme-to-real-screen expected-grapheme + 978 print-string-to-real-screen "' at (" + 979 print-int32-hex-to-real-screen row-idx + 980 print-string-to-real-screen ", " + 981 print-int32-hex-to-real-screen col-idx + 982 print-string-to-real-screen ") to be underlined\n" + 983 } + 984 } + 985 idx <- increment + 986 increment col-idx + 987 loop + 988 } + 989 } + 990 + 991 fn check-screen-row-in-reverse screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { + 992 check-screen-row-in-reverse-from screen, row-idx, 1, expected, msg 993 } 994 - 995 fn test-move-cursor-column-too-large { - 996 var screen-on-stack: screen - 997 var screen/esi: (addr screen) <- address screen-on-stack - 998 initialize-screen screen, 5, 3 # 5 rows, 3 columns - 999 move-cursor screen, 1, 4 # row 1, column 4 (overflow) -1000 var c/eax: grapheme <- copy 0x61 # 'a' -1001 print-grapheme screen, c -1002 # top row is empty -1003 check-screen-row screen, 1, " ", "F - test-move-cursor-column-too-large" -1004 # character shows up on next row -1005 check-screen-row screen, 2, "a", "F - test-move-cursor-column-too-large" -1006 } -1007 -1008 fn test-move-cursor-column-too-large-saturates { -1009 var screen-on-stack: screen -1010 var screen/esi: (addr screen) <- address screen-on-stack -1011 initialize-screen screen, 5, 3 # 5 rows, 3 columns -1012 move-cursor screen, 1, 6 # row 1, column 6 (overflow) -1013 var c/eax: grapheme <- copy 0x61 # 'a' -1014 print-grapheme screen, c -1015 # top row is empty -1016 check-screen-row screen, 1, " ", "F - test-move-cursor-column-too-large-saturates" # top-left corner of the screen -1017 # character shows up at the start of next row -1018 check-screen-row screen, 2, "a", "F - test-move-cursor-column-too-large-saturates" # top-left corner of the screen -1019 } -1020 -1021 fn test-move-cursor-row-too-large { -1022 var screen-on-stack: screen -1023 var screen/esi: (addr screen) <- address screen-on-stack -1024 initialize-screen screen, 5, 3 # 5 rows -1025 move-cursor screen, 6, 2 # row 6 (overflow) -1026 var c/eax: grapheme <- copy 0x61 # 'a' -1027 print-grapheme screen, c -1028 # bottom row shows the character -1029 check-screen-row screen, 5, " a", "F - test-move-cursor-row-too-large" -1030 } -1031 -1032 fn test-move-cursor-row-too-large-saturates { -1033 var screen-on-stack: screen -1034 var screen/esi: (addr screen) <- address screen-on-stack -1035 initialize-screen screen, 5, 3 # 5 rows -1036 move-cursor screen, 9, 2 # row 9 (overflow) -1037 var c/eax: grapheme <- copy 0x61 # 'a' -1038 print-grapheme screen, c -1039 # bottom row shows the character -1040 check-screen-row screen, 5, " a", "F - test-move-cursor-row-too-large-saturates" -1041 } -1042 -1043 fn test-check-screen-row-from { -1044 var screen-on-stack: screen -1045 var screen/esi: (addr screen) <- address screen-on-stack -1046 initialize-screen screen, 5, 4 -1047 move-cursor screen, 1, 4 -1048 var c/eax: grapheme <- copy 0x61 # 'a' -1049 print-grapheme screen, c -1050 check-screen-row screen, 1, " a", "F - test-check-screen-row-from/baseline" -1051 check-screen-row-from screen, 1, 4, "a", "F - test-check-screen-row-from" -1052 } -1053 -1054 fn test-print-string-overflows-to-next-row { -1055 var screen-on-stack: screen -1056 var screen/esi: (addr screen) <- address screen-on-stack -1057 initialize-screen screen, 5, 4 # 5 rows, 4 columns -1058 print-string screen, "abcdefg" -1059 check-screen-row screen, 1, "abcd", "F - test-print-string-overflows-to-next-row" -1060 check-screen-row screen, 2, "efg", "F - test-print-string-overflows-to-next-row" -1061 } -1062 -1063 fn test-check-screen-scrolls-on-overflow { -1064 var screen-on-stack: screen -1065 var screen/esi: (addr screen) <- address screen-on-stack -1066 initialize-screen screen, 5, 4 -1067 # single character starting at bottom right -1068 move-cursor screen, 5, 4 -1069 var c/eax: grapheme <- copy 0x61 # 'a' -1070 print-grapheme screen, c -1071 check-screen-row-from screen, 5, 4, "a", "F - test-check-screen-scrolls-on-overflow/baseline" # bottom-right corner of the screen -1072 # multiple characters starting at bottom right -1073 move-cursor screen, 5, 4 -1074 print-string screen, "ab" -1075 # screen scrolled up one row -1076 #? check-screen-row screen, 1, " ", "F - test-check-screen-scrolls-on-overflow/x1" -1077 #? check-screen-row screen, 2, " ", "F - test-check-screen-scrolls-on-overflow/x2" -1078 #? check-screen-row screen, 3, " ", "F - test-check-screen-scrolls-on-overflow/x3" -1079 #? check-screen-row screen, 4, " a", "F - test-check-screen-scrolls-on-overflow/x4" -1080 #? check-screen-row screen, 5, "b ", "F - test-check-screen-scrolls-on-overflow/x5" -1081 check-screen-row-from screen, 4, 4, "a", "F - test-check-screen-scrolls-on-overflow/1" -1082 check-screen-row-from screen, 5, 1, "b", "F - test-check-screen-scrolls-on-overflow/2" -1083 } -1084 -1085 fn test-check-screen-color { -1086 var screen-on-stack: screen -1087 var screen/esi: (addr screen) <- address screen-on-stack -1088 initialize-screen screen, 5, 4 -1089 var c/eax: grapheme <- copy 0x61 # 'a' -1090 print-grapheme screen, c -1091 start-color screen, 1, 0 # foreground=1 -1092 c <- copy 0x62 # 'b' -1093 print-grapheme screen, c -1094 start-color screen, 0, 0 # back to default -1095 c <- copy 0x63 # 'c' -1096 print-grapheme screen, c -1097 check-screen-row-in-color screen, 0, 1, "a c", "F - test-check-screen-color" -1098 } -1099 -1100 fn test-check-screen-background-color { -1101 var screen-on-stack: screen -1102 var screen/esi: (addr screen) <- address screen-on-stack -1103 initialize-screen screen, 5, 4 -1104 var c/eax: grapheme <- copy 0x61 # 'a' -1105 print-grapheme screen, c -1106 start-color screen, 0, 1 # background=1 -1107 c <- copy 0x62 # 'b' -1108 print-grapheme screen, c -1109 start-color screen, 0, 7 # back to default -1110 c <- copy 0x63 # 'c' -1111 print-grapheme screen, c -1112 check-screen-row-in-background-color screen, 7, 1, "a c", "F - test-check-screen-background-color" -1113 } -1114 -1115 fn test-check-screen-bold { -1116 var screen-on-stack: screen -1117 var screen/esi: (addr screen) <- address screen-on-stack -1118 initialize-screen screen, 5, 4 -1119 start-bold screen -1120 var c/eax: grapheme <- copy 0x61 # 'a' -1121 print-grapheme screen, c -1122 reset-formatting screen -1123 c <- copy 0x62 # 'b' -1124 print-grapheme screen, c -1125 start-bold screen -1126 c <- copy 0x63 # 'c' -1127 print-grapheme screen, c -1128 check-screen-row-in-bold screen, 1, "a c", "F - test-check-screen-bold" -1129 } -1130 -1131 fn test-check-screen-underline { -1132 var screen-on-stack: screen -1133 var screen/esi: (addr screen) <- address screen-on-stack -1134 initialize-screen screen, 5, 4 -1135 start-underline screen -1136 var c/eax: grapheme <- copy 0x61 # 'a' -1137 print-grapheme screen, c -1138 reset-formatting screen -1139 c <- copy 0x62 # 'b' -1140 print-grapheme screen, c -1141 start-underline screen -1142 c <- copy 0x63 # 'c' -1143 print-grapheme screen, c -1144 check-screen-row-in-underline screen, 1, "a c", "F - test-check-screen-underline" -1145 } -1146 -1147 fn test-check-screen-reverse { -1148 var screen-on-stack: screen -1149 var screen/esi: (addr screen) <- address screen-on-stack -1150 initialize-screen screen, 5, 4 -1151 start-reverse-video screen -1152 var c/eax: grapheme <- copy 0x61 # 'a' -1153 print-grapheme screen, c -1154 reset-formatting screen -1155 c <- copy 0x62 # 'b' -1156 print-grapheme screen, c -1157 start-reverse-video screen -1158 c <- copy 0x63 # 'c' + 995 fn check-screen-row-in-reverse-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { + 996 var screen/esi: (addr screen) <- copy screen-on-stack + 997 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx + 998 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme + 999 var e: (stream byte 0x100) +1000 var e-addr/edx: (addr stream byte) <- address e +1001 write e-addr, expected +1002 { +1003 var done?/eax: boolean <- stream-empty? e-addr +1004 compare done?, 0 +1005 break-if-!= +1006 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx +1007 var g/ebx: grapheme <- copy _g +1008 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr +1009 var expected-grapheme/edx: grapheme <- copy _expected-grapheme +1010 $check-screen-row-in-reverse-from:compare-cells: { +1011 # if expected-grapheme is space, null grapheme is also ok +1012 { +1013 compare expected-grapheme, 0x20 +1014 break-if-!= +1015 compare g, 0 +1016 break-if-= $check-screen-row-in-reverse-from:compare-cells +1017 } +1018 # if expected-grapheme is space, non-reverse is ok +1019 { +1020 compare expected-grapheme, 0x20 +1021 break-if-!= +1022 var reverse?/eax: boolean <- screen-reverse-at-idx? screen, idx +1023 compare reverse?, 1 +1024 break-if-!= $check-screen-row-in-reverse-from:compare-cells +1025 } +1026 # compare graphemes +1027 $check-screen-row-in-reverse-from:compare-graphemes: { +1028 # if (g == expected-grapheme) print "." +1029 compare g, expected-grapheme +1030 { +1031 break-if-!= +1032 print-string-to-real-screen "." +1033 break $check-screen-row-in-reverse-from:compare-graphemes +1034 } +1035 # otherwise print an error +1036 print-string-to-real-screen msg +1037 print-string-to-real-screen ": expected '" +1038 print-grapheme-to-real-screen expected-grapheme +1039 print-string-to-real-screen "' at (" +1040 print-int32-hex-to-real-screen row-idx +1041 print-string-to-real-screen ", " +1042 print-int32-hex-to-real-screen col-idx +1043 print-string-to-real-screen ") but observed '" +1044 print-grapheme-to-real-screen g +1045 print-string-to-real-screen "'\n" +1046 } +1047 $check-screen-row-in-reverse-from:compare-reverse: { +1048 var reverse?/eax: boolean <- screen-reverse-at-idx? screen, idx +1049 compare reverse?, 1 +1050 { +1051 break-if-!= +1052 print-string-to-real-screen "." +1053 break $check-screen-row-in-reverse-from:compare-reverse +1054 } +1055 # otherwise print an error +1056 print-string-to-real-screen msg +1057 print-string-to-real-screen ": expected '" +1058 print-grapheme-to-real-screen expected-grapheme +1059 print-string-to-real-screen "' at (" +1060 print-int32-hex-to-real-screen row-idx +1061 print-string-to-real-screen ", " +1062 print-int32-hex-to-real-screen col-idx +1063 print-string-to-real-screen ") to be in reverse-video\n" +1064 } +1065 } +1066 idx <- increment +1067 increment col-idx +1068 loop +1069 } +1070 } +1071 +1072 fn check-screen-row-in-blinking screen: (addr screen), row-idx: int, expected: (addr array byte), msg: (addr array byte) { +1073 check-screen-row-in-blinking-from screen, row-idx, 1, expected, msg +1074 } +1075 +1076 fn check-screen-row-in-blinking-from screen-on-stack: (addr screen), row-idx: int, col-idx: int, expected: (addr array byte), msg: (addr array byte) { +1077 var screen/esi: (addr screen) <- copy screen-on-stack +1078 var idx/ecx: int <- screen-cell-index screen, row-idx, col-idx +1079 # compare 'expected' with the screen contents starting at 'idx', grapheme by grapheme +1080 var e: (stream byte 0x100) +1081 var e-addr/edx: (addr stream byte) <- address e +1082 write e-addr, expected +1083 { +1084 var done?/eax: boolean <- stream-empty? e-addr +1085 compare done?, 0 +1086 break-if-!= +1087 var _g/eax: grapheme <- screen-grapheme-at-idx screen, idx +1088 var g/ebx: grapheme <- copy _g +1089 var _expected-grapheme/eax: grapheme <- read-grapheme e-addr +1090 var expected-grapheme/edx: grapheme <- copy _expected-grapheme +1091 $check-screen-row-in-blinking-from:compare-cells: { +1092 # if expected-grapheme is space, null grapheme is also ok +1093 { +1094 compare expected-grapheme, 0x20 +1095 break-if-!= +1096 compare g, 0 +1097 break-if-= $check-screen-row-in-blinking-from:compare-cells +1098 } +1099 # if expected-grapheme is space, non-blinking is ok +1100 { +1101 compare expected-grapheme, 0x20 +1102 break-if-!= +1103 var blinking?/eax: boolean <- screen-blink-at-idx? screen, idx +1104 compare blinking?, 1 +1105 break-if-!= $check-screen-row-in-blinking-from:compare-cells +1106 } +1107 # compare graphemes +1108 $check-screen-row-in-blinking-from:compare-graphemes: { +1109 # if (g == expected-grapheme) print "." +1110 compare g, expected-grapheme +1111 { +1112 break-if-!= +1113 print-string-to-real-screen "." +1114 break $check-screen-row-in-blinking-from:compare-graphemes +1115 } +1116 # otherwise print an error +1117 print-string-to-real-screen msg +1118 print-string-to-real-screen ": expected '" +1119 print-grapheme-to-real-screen expected-grapheme +1120 print-string-to-real-screen "' at (" +1121 print-int32-hex-to-real-screen row-idx +1122 print-string-to-real-screen ", " +1123 print-int32-hex-to-real-screen col-idx +1124 print-string-to-real-screen ") but observed '" +1125 print-grapheme-to-real-screen g +1126 print-string-to-real-screen "'\n" +1127 } +1128 $check-screen-row-in-blinking-from:compare-blinking: { +1129 var blinking?/eax: boolean <- screen-blink-at-idx? screen, idx +1130 compare blinking?, 1 +1131 { +1132 break-if-!= +1133 print-string-to-real-screen "." +1134 break $check-screen-row-in-blinking-from:compare-blinking +1135 } +1136 # otherwise print an error +1137 print-string-to-real-screen msg +1138 print-string-to-real-screen ": expected '" +1139 print-grapheme-to-real-screen expected-grapheme +1140 print-string-to-real-screen "' at (" +1141 print-int32-hex-to-real-screen row-idx +1142 print-string-to-real-screen ", " +1143 print-int32-hex-to-real-screen col-idx +1144 print-string-to-real-screen ") to be blinking\n" +1145 } +1146 } +1147 idx <- increment +1148 increment col-idx +1149 +1150 loop +1151 } +1152 } +1153 +1154 fn test-print-single-grapheme { +1155 var screen-on-stack: screen +1156 var screen/esi: (addr screen) <- address screen-on-stack +1157 initialize-screen screen, 5, 4 +1158 var c/eax: grapheme <- copy 0x61 # 'a' 1159 print-grapheme screen, c -1160 check-screen-row-in-reverse screen, 1, "a c", "F - test-check-screen-reverse" +1160 check-screen-row screen, 1, "a", "F - test-print-single-grapheme" # top-left corner of the screen 1161 } 1162 -1163 fn test-check-screen-blinking { +1163 fn test-print-multiple-graphemes { 1164 var screen-on-stack: screen 1165 var screen/esi: (addr screen) <- address screen-on-stack 1166 initialize-screen screen, 5, 4 -1167 start-blinking screen -1168 var c/eax: grapheme <- copy 0x61 # 'a' -1169 print-grapheme screen, c -1170 reset-formatting screen -1171 c <- copy 0x62 # 'b' -1172 print-grapheme screen, c -1173 start-blinking screen -1174 c <- copy 0x63 # 'c' -1175 print-grapheme screen, c -1176 check-screen-row-in-blinking screen, 1, "a c", "F - test-check-screen-blinking" -1177 } -1178 -1179 #? fn main -> exit-status/ebx: int { -1180 #? #? test-check-screen-color -1181 #? run-tests -1182 #? exit-status <- copy 0 -1183 #? } +1167 print-string screen, "Hello, 世界" +1168 check-screen-row screen, 1, "Hello, 世界", "F - test-print-multiple-graphemes" +1169 } +1170 +1171 fn test-move-cursor { +1172 var screen-on-stack: screen +1173 var screen/esi: (addr screen) <- address screen-on-stack +1174 initialize-screen screen, 5, 4 +1175 move-cursor screen, 1, 4 +1176 var c/eax: grapheme <- copy 0x61 # 'a' +1177 print-grapheme screen, c +1178 check-screen-row screen, 1, " a", "F - test-move-cursor" # top row +1179 } +1180 +1181 fn test-move-cursor-zeroes { +1182 var screen-on-stack: screen +1183 var screen/esi: (addr screen) <- address screen-on-stack +1184 initialize-screen screen, 5, 4 +1185 move-cursor screen, 0, 0 +1186 var c/eax: grapheme <- copy 0x61 # 'a' +1187 print-grapheme screen, c +1188 check-screen-row screen, 1, "a", "F - test-move-cursor-zeroes" # top-left corner of the screen +1189 } +1190 +1191 fn test-move-cursor-zero-row { +1192 var screen-on-stack: screen +1193 var screen/esi: (addr screen) <- address screen-on-stack +1194 initialize-screen screen, 5, 4 +1195 move-cursor screen, 0, 2 +1196 var c/eax: grapheme <- copy 0x61 # 'a' +1197 print-grapheme screen, c +1198 check-screen-row screen, 1, " a", "F - test-move-cursor-zero-row" # top row +1199 } +1200 +1201 fn test-move-cursor-zero-column { +1202 var screen-on-stack: screen +1203 var screen/esi: (addr screen) <- address screen-on-stack +1204 initialize-screen screen, 5, 4 +1205 move-cursor screen, 4, 0 +1206 var c/eax: grapheme <- copy 0x61 # 'a' +1207 print-grapheme screen, c +1208 check-screen-row screen, 4, "a", "F - test-move-cursor-zero-column" +1209 } +1210 +1211 fn test-move-cursor-negative-row { +1212 var screen-on-stack: screen +1213 var screen/esi: (addr screen) <- address screen-on-stack +1214 initialize-screen screen, 5, 3 +1215 move-cursor screen, -1, 2 # row -1 +1216 var c/eax: grapheme <- copy 0x61 # 'a' +1217 print-grapheme screen, c +1218 # no move +1219 check-screen-row screen, 1, "a", "F - test-move-cursor-negative-row" +1220 } +1221 +1222 fn test-move-cursor-negative-column { +1223 var screen-on-stack: screen +1224 var screen/esi: (addr screen) <- address screen-on-stack +1225 initialize-screen screen, 5, 3 +1226 move-cursor screen, 2, -1 # column -1 +1227 var c/eax: grapheme <- copy 0x61 # 'a' +1228 print-grapheme screen, c +1229 # no move +1230 check-screen-row screen, 1, "a", "F - test-move-cursor-negative-column" +1231 } +1232 +1233 fn test-move-cursor-column-too-large { +1234 var screen-on-stack: screen +1235 var screen/esi: (addr screen) <- address screen-on-stack +1236 initialize-screen screen, 5, 3 # 5 rows, 3 columns +1237 move-cursor screen, 1, 4 # row 1, column 4 (overflow) +1238 var c/eax: grapheme <- copy 0x61 # 'a' +1239 print-grapheme screen, c +1240 # top row is empty +1241 check-screen-row screen, 1, " ", "F - test-move-cursor-column-too-large" +1242 # character shows up on next row +1243 check-screen-row screen, 2, "a", "F - test-move-cursor-column-too-large" +1244 } +1245 +1246 fn test-move-cursor-column-too-large-saturates { +1247 var screen-on-stack: screen +1248 var screen/esi: (addr screen) <- address screen-on-stack +1249 initialize-screen screen, 5, 3 # 5 rows, 3 columns +1250 move-cursor screen, 1, 6 # row 1, column 6 (overflow) +1251 var c/eax: grapheme <- copy 0x61 # 'a' +1252 print-grapheme screen, c +1253 # top row is empty +1254 check-screen-row screen, 1, " ", "F - test-move-cursor-column-too-large-saturates" # top-left corner of the screen +1255 # character shows up at the start of next row +1256 check-screen-row screen, 2, "a", "F - test-move-cursor-column-too-large-saturates" # top-left corner of the screen +1257 } +1258 +1259 fn test-move-cursor-row-too-large { +1260 var screen-on-stack: screen +1261 var screen/esi: (addr screen) <- address screen-on-stack +1262 initialize-screen screen, 5, 3 # 5 rows +1263 move-cursor screen, 6, 2 # row 6 (overflow) +1264 var c/eax: grapheme <- copy 0x61 # 'a' +1265 print-grapheme screen, c +1266 # bottom row shows the character +1267 check-screen-row screen, 5, " a", "F - test-move-cursor-row-too-large" +1268 } +1269 +1270 fn test-move-cursor-row-too-large-saturates { +1271 var screen-on-stack: screen +1272 var screen/esi: (addr screen) <- address screen-on-stack +1273 initialize-screen screen, 5, 3 # 5 rows +1274 move-cursor screen, 9, 2 # row 9 (overflow) +1275 var c/eax: grapheme <- copy 0x61 # 'a' +1276 print-grapheme screen, c +1277 # bottom row shows the character +1278 check-screen-row screen, 5, " a", "F - test-move-cursor-row-too-large-saturates" +1279 } +1280 +1281 fn test-check-screen-row-from { +1282 var screen-on-stack: screen +1283 var screen/esi: (addr screen) <- address screen-on-stack +1284 initialize-screen screen, 5, 4 +1285 move-cursor screen, 1, 4 +1286 var c/eax: grapheme <- copy 0x61 # 'a' +1287 print-grapheme screen, c +1288 check-screen-row screen, 1, " a", "F - test-check-screen-row-from/baseline" +1289 check-screen-row-from screen, 1, 4, "a", "F - test-check-screen-row-from" +1290 } +1291 +1292 fn test-print-string-overflows-to-next-row { +1293 var screen-on-stack: screen +1294 var screen/esi: (addr screen) <- address screen-on-stack +1295 initialize-screen screen, 5, 4 # 5 rows, 4 columns +1296 print-string screen, "abcdefg" +1297 check-screen-row screen, 1, "abcd", "F - test-print-string-overflows-to-next-row" +1298 check-screen-row screen, 2, "efg", "F - test-print-string-overflows-to-next-row" +1299 } +1300 +1301 fn test-check-screen-scrolls-on-overflow { +1302 var screen-on-stack: screen +1303 var screen/esi: (addr screen) <- address screen-on-stack +1304 initialize-screen screen, 5, 4 +1305 # single character starting at bottom right +1306 move-cursor screen, 5, 4 +1307 var c/eax: grapheme <- copy 0x61 # 'a' +1308 print-grapheme screen, c +1309 check-screen-row-from screen, 5, 4, "a", "F - test-check-screen-scrolls-on-overflow/baseline" # bottom-right corner of the screen +1310 # multiple characters starting at bottom right +1311 move-cursor screen, 5, 4 +1312 print-string screen, "ab" +1313 # screen scrolled up one row +1314 #? check-screen-row screen, 1, " ", "F - test-check-screen-scrolls-on-overflow/x1" +1315 #? check-screen-row screen, 2, " ", "F - test-check-screen-scrolls-on-overflow/x2" +1316 #? check-screen-row screen, 3, " ", "F - test-check-screen-scrolls-on-overflow/x3" +1317 #? check-screen-row screen, 4, " a", "F - test-check-screen-scrolls-on-overflow/x4" +1318 #? check-screen-row screen, 5, "b ", "F - test-check-screen-scrolls-on-overflow/x5" +1319 check-screen-row-from screen, 4, 4, "a", "F - test-check-screen-scrolls-on-overflow/1" +1320 check-screen-row-from screen, 5, 1, "b", "F - test-check-screen-scrolls-on-overflow/2" +1321 } +1322 +1323 fn test-check-screen-color { +1324 var screen-on-stack: screen +1325 var screen/esi: (addr screen) <- address screen-on-stack +1326 initialize-screen screen, 5, 4 +1327 var c/eax: grapheme <- copy 0x61 # 'a' +1328 print-grapheme screen, c +1329 start-color screen, 1, 0 # foreground=1 +1330 c <- copy 0x62 # 'b' +1331 print-grapheme screen, c +1332 start-color screen, 0, 0 # back to default +1333 c <- copy 0x63 # 'c' +1334 print-grapheme screen, c +1335 check-screen-row-in-color screen, 0, 1, "a c", "F - test-check-screen-color" +1336 } +1337 +1338 fn test-check-screen-background-color { +1339 var screen-on-stack: screen +1340 var screen/esi: (addr screen) <- address screen-on-stack +1341 initialize-screen screen, 5, 4 +1342 var c/eax: grapheme <- copy 0x61 # 'a' +1343 print-grapheme screen, c +1344 start-color screen, 0, 1 # background=1 +1345 c <- copy 0x62 # 'b' +1346 print-grapheme screen, c +1347 start-color screen, 0, 7 # back to default +1348 c <- copy 0x63 # 'c' +1349 print-grapheme screen, c +1350 check-screen-row-in-background-color screen, 7, 1, "a c", "F - test-check-screen-background-color" +1351 } +1352 +1353 fn test-check-screen-bold { +1354 var screen-on-stack: screen +1355 var screen/esi: (addr screen) <- address screen-on-stack +1356 initialize-screen screen, 5, 4 +1357 start-bold screen +1358 var c/eax: grapheme <- copy 0x61 # 'a' +1359 print-grapheme screen, c +1360 reset-formatting screen +1361 c <- copy 0x62 # 'b' +1362 print-grapheme screen, c +1363 start-bold screen +1364 c <- copy 0x63 # 'c' +1365 print-grapheme screen, c +1366 check-screen-row-in-bold screen, 1, "a c", "F - test-check-screen-bold" +1367 } +1368 +1369 fn test-check-screen-underline { +1370 var screen-on-stack: screen +1371 var screen/esi: (addr screen) <- address screen-on-stack +1372 initialize-screen screen, 5, 4 +1373 start-underline screen +1374 var c/eax: grapheme <- copy 0x61 # 'a' +1375 print-grapheme screen, c +1376 reset-formatting screen +1377 c <- copy 0x62 # 'b' +1378 print-grapheme screen, c +1379 start-underline screen +1380 c <- copy 0x63 # 'c' +1381 print-grapheme screen, c +1382 check-screen-row-in-underline screen, 1, "a c", "F - test-check-screen-underline" +1383 } +1384 +1385 fn test-check-screen-reverse { +1386 var screen-on-stack: screen +1387 var screen/esi: (addr screen) <- address screen-on-stack +1388 initialize-screen screen, 5, 4 +1389 start-reverse-video screen +1390 var c/eax: grapheme <- copy 0x61 # 'a' +1391 print-grapheme screen, c +1392 reset-formatting screen +1393 c <- copy 0x62 # 'b' +1394 print-grapheme screen, c +1395 start-reverse-video screen +1396 c <- copy 0x63 # 'c' +1397 print-grapheme screen, c +1398 check-screen-row-in-reverse screen, 1, "a c", "F - test-check-screen-reverse" +1399 } +1400 +1401 fn test-check-screen-blinking { +1402 var screen-on-stack: screen +1403 var screen/esi: (addr screen) <- address screen-on-stack +1404 initialize-screen screen, 5, 4 +1405 start-blinking screen +1406 var c/eax: grapheme <- copy 0x61 # 'a' +1407 print-grapheme screen, c +1408 reset-formatting screen +1409 c <- copy 0x62 # 'b' +1410 print-grapheme screen, c +1411 start-blinking screen +1412 c <- copy 0x63 # 'c' +1413 print-grapheme screen, c +1414 check-screen-row-in-blinking screen, 1, "a c", "F - test-check-screen-blinking" +1415 } +1416 +1417 #? fn main -> exit-status/ebx: int { +1418 #? #? test-check-screen-color +1419 #? run-tests +1420 #? exit-status <- copy 0 +1421 #? } -- cgit 1.4.1-2-gfad0