source: trunk/essentials/sys-libs/ncurses/tack/modes.c

Last change on this file was 2621, checked in by bird, 19 years ago

GNU ncurses 5.5
File size: 20.5 KB
Line 
1/*
2** Copyright (C) 1991, 1997 Free Software Foundation, Inc.
3**
4** This file is part of TACK.
5**
6** TACK is free software; you can redistribute it and/or modify
7** it under the terms of the GNU General Public License as published by
8** the Free Software Foundation; either version 2, or (at your option)
9** any later version.
10**
11** TACK is distributed in the hope that it will be useful,
12** but WITHOUT ANY WARRANTY; without even the implied warranty of
13** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14** GNU General Public License for more details.
15**
16** You should have received a copy of the GNU General Public License
17** along with TACK; see the file COPYING. If not, write to
18** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19** Boston, MA 02110-1301, USA
20*/
21
22#include <tack.h>
23
24MODULE_ID("$Id: modes.c,v 1.2 2005/09/17 19:49:16 tom Exp $")
25
26/*
27 * Tests boolean flags and terminal modes.
28 */
29static void subtest_os(struct test_list *, int *, int *);
30static void subtest_rmam(struct test_list *, int *, int *);
31static void subtest_smam(struct test_list *, int *, int *);
32static void subtest_am(struct test_list *, int *, int *);
33static void subtest_ul(struct test_list *, int *, int *);
34static void subtest_uc(struct test_list *, int *, int *);
35static void subtest_bw(struct test_list *, int *, int *);
36static void subtest_xenl(struct test_list *, int *, int *);
37static void subtest_eo(struct test_list *, int *, int *);
38static void subtest_xmc(struct test_list *, int *, int *);
39static void subtest_xhp(struct test_list *, int *, int *);
40static void subtest_mir(struct test_list *, int *, int *);
41static void subtest_msgr(struct test_list *, int *, int *);
42static void subtest_tbc(struct test_list *, int *, int *);
43static void subtest_xt(struct test_list *, int *, int *);
44static void subtest_hts(struct test_list *, int *, int *);
45static void subtest_cbt(struct test_list *, int *, int *);
46static void subtest_in(struct test_list *, int *, int *);
47static void subtest_dadb(struct test_list *, int *, int *);
48
49struct test_list mode_test_list[] = {
50 {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu},
51 {MENU_NEXT, 3, "os", 0, 0, subtest_os, 0},
52 {MENU_NEXT, 1, "rmam", 0, 0, subtest_rmam, 0},
53 {MENU_NEXT, 1, "smam", 0, 0, subtest_smam, 0},
54 {MENU_NEXT, 1, "am", 0, 0, subtest_am, 0},
55 {MENU_NEXT, 3, "ul", 0, 0, subtest_ul, 0},
56 {MENU_NEXT, 3, "uc", 0, 0, subtest_uc, 0},
57 {MENU_NEXT, 3, "bw", 0, 0, subtest_bw, 0},
58 {MENU_NEXT, 4, "xenl", 0, 0, subtest_xenl, 0},
59 {MENU_NEXT, 3, "eo", 0, 0, subtest_eo, 0},
60 {MENU_NEXT, 3, "xmc", 0, 0, subtest_xmc, 0},
61 {MENU_NEXT, 3, "xhp", 0, 0, subtest_xhp, 0},
62 {MENU_NEXT, 6, "mir", 0, 0, subtest_mir, 0},
63 {MENU_NEXT, 6, "msgr", 0, 0, subtest_msgr, 0},
64 {MENU_NEXT | MENU_CLEAR, 0, "tbc", "it", 0, subtest_tbc, 0},
65 {MENU_NEXT | MENU_CLEAR, 0, "hts", "it", 0, subtest_hts, 0},
66 {MENU_NEXT, 4, "xt", "it", 0, subtest_xt, 0},
67 {MENU_NEXT, 1, "cbt", "it", 0, subtest_cbt, 0},
68 {MENU_NEXT, 6, "in", 0, 0, subtest_in, 0},
69 {MENU_NEXT, 1, "da) (db", 0, 0, subtest_dadb, 0},
70 {MENU_LAST, 0, 0, 0, 0, 0, 0}
71};
72
73/*
74** subtest_os(test_list, status, ch)
75**
76** test over strike mode (os)
77*/
78static void
79subtest_os(
80 struct test_list *t,
81 int *state,
82 int *ch)
83{
84 ptext("(os) should be true, not false.");
85 put_cr();
86 ptextln("(os) should be false.");
87 sprintf(temp, "(os) over-strike is %s in the data base. ",
88 over_strike ? "true" : "false");
89 ptext(temp);
90 generic_done_message(t, state, ch);
91}
92
93/*
94** subtest_rmam(test_list, status, ch)
95**
96** test exit automatic margins mode (rmam)
97*/
98static void
99subtest_rmam(
100 struct test_list *t,
101 int *state,
102 int *ch)
103{
104 int j;
105
106 if (!exit_am_mode) {
107 ptext("(rmam) not present. ");
108 } else
109 if (!can_go_home) {
110 ptext("(rmam) not tested, no way to home cursor. ");
111 } else
112 if (over_strike) {
113 put_clear();
114 go_home();
115 tc_putp(exit_am_mode);
116 ptext("\n(rmam) will reset (am)");
117 go_home();
118 for (j = 0; j < columns; j++)
119 put_this(' ');
120 ptext("(rmam) will not reset (am)");
121 go_home();
122 put_newlines(2);
123 } else {
124 put_clear();
125 go_home();
126 tc_putp(exit_am_mode);
127 ptext("\n(rmam) will reset (am)");
128 go_home();
129 for (j = 0; j < columns; j++)
130 put_this(' ');
131 ptext("(rmam) will not reset (am) ");
132 go_home();
133 put_str(" ");
134 go_home();
135 put_newlines(2);
136 }
137 ptext("Exit-automatic-margins ");
138 generic_done_message(t, state, ch);
139}
140
141/*
142** subtest_smam(test_list, status, ch)
143**
144** test enter automatic margins mode (smam)
145*/
146static void
147subtest_smam(
148 struct test_list *t,
149 int *state,
150 int *ch)
151{
152 int i, j;
153
154 if (!enter_am_mode) {
155 ptext("(smam) not present. ");
156 } else
157 if (!can_go_home) {
158 ptext("(smam) not tested, no way to home cursor. ");
159 } else
160 if (over_strike) {
161 put_clear();
162 go_home();
163 tc_putp(enter_am_mode);
164 ptext("\n(smam) will ");
165 i = char_count;
166 ptext("not set (am)");
167 go_home();
168 for (j = -i; j < columns; j++)
169 put_this(' ');
170 put_str("@@@");
171 put_newlines(2);
172 } else {
173 put_clear();
174 go_home();
175 tc_putp(enter_am_mode);
176 ptext("\n(smam) will not set (am)");
177 go_home();
178 for (j = 0; j < columns; j++)
179 put_this(' ');
180 ptext("(smam) will set (am) ");
181 go_home();
182 put_str(" ");
183 put_newlines(2);
184 }
185 ptext("Enter-automatic-margins ");
186 generic_done_message(t, state, ch);
187}
188
189/*
190** subtest_am(test_list, status, ch)
191**
192** test automatic margins (am)
193*/
194static void
195subtest_am(
196 struct test_list *t,
197 int *state,
198 int *ch)
199{
200 int i, j;
201
202 if (!can_go_home) {
203 ptextln("(am) not tested, no way to home cursor. ");
204 } else
205 if (over_strike) {
206 put_clear();
207 go_home();
208 ptext("\n(am) should ");
209 i = char_count;
210 ptext("not be set");
211 go_home();
212 for (j = -i; j < columns; j++)
213 put_this(' ');
214 put_str("@@@");
215 go_home();
216 put_newlines(2);
217 sprintf(temp, "(am) is %s in the data base",
218 auto_right_margin ? "true" : "false");
219 ptextln(temp);
220 } else {
221 put_clear();
222 go_home();
223 ptext("\n(am) should not be set");
224 go_home();
225 for (j = 0; j < columns; j++)
226 put_this(' ');
227 ptext("(am) should be set ");
228 go_home();
229 put_str(" \n\n");
230 sprintf(temp, "(am) is %s in the data base",
231 auto_right_margin ? "true" : "false");
232 ptextln(temp);
233 }
234 ptext("Automatic-right-margin ");
235 generic_done_message(t, state, ch);
236}
237
238/* Note: uprint() sends underscore back-space character, and
239 ucprint() sends character back-space underscore. */
240
241/*
242** uprint(string)
243**
244** underline string for (ul) test
245*/
246static void
247uprint(const char *s)
248{
249 if (s) {
250 while (*s) {
251 put_str("_\b");
252 putchp(*s++);
253 }
254 }
255}
256
257/*
258** ucprint(string)
259**
260** underline string for (uc) test
261*/
262static void
263ucprint(const char *s)
264{
265 if (s) {
266 while (*s) {
267 putchp(*s++);
268 putchp('\b');
269 tc_putp(underline_char);
270 }
271 }
272}
273
274/*
275** subtest_ul(test_list, status, ch)
276**
277** test transparent underline (ul)
278*/
279static void
280subtest_ul(
281 struct test_list *t,
282 int *state,
283 int *ch)
284{
285 if (!over_strike) {
286 /* (ul) is used only if (os) is reset */
287 put_crlf();
288 sprintf(temp, "This text should %sbe underlined.",
289 transparent_underline ? "" : "not ");
290 uprint(temp);
291 put_crlf();
292 ptextln("If the above line is not underlined the (ul) should be false.");
293 sprintf(temp, "(ul) Transparent-underline is %s in the data base",
294 transparent_underline ? "true" : "false");
295 ptextln(temp);
296 generic_done_message(t, state, ch);
297 }
298}
299
300/*
301** subtest_uc(test_list, status, ch)
302**
303** test underline character (uc)
304*/
305static void
306subtest_uc(
307 struct test_list *t,
308 int *state,
309 int *ch)
310{
311 if (!over_strike) {
312 if (underline_char) {
313 ucprint("This text should be underlined.");
314 put_crlf();
315 ptextln("If the above text is not underlined the (uc) has failed.");
316 ptext("Underline-character ");
317 } else {
318 ptext("(uc) underline-character is not defined. ");
319 }
320 generic_done_message(t, state, ch);
321 }
322}
323
324/*
325** subtest_bw(test_list, status, ch)
326**
327** test auto left margin (bw)
328*/
329static void
330subtest_bw(
331 struct test_list *t,
332 int *state,
333 int *ch)
334{
335 int i, j;
336
337 if (over_strike) {
338 /* test (bw) */
339 ptext("\n(bw) should ");
340 i = char_count;
341 ptextln("not be set.");
342 for (j = i; j < columns; j++)
343 put_str("\b");
344 put_str("@@@");
345 put_crlf();
346 sprintf(temp, "(bw) Auto-left-margin is %s in the data base",
347 auto_left_margin ? "true" : "false");
348 ptextln(temp);
349 } else {
350 /* test (bw) */
351 ptextln("(bw) should not be set.");
352 for (i = 12; i < columns; i++)
353 put_str("\b");
354 if (delete_character) {
355 for (i = 0; i < 4; i++)
356 tc_putp(delete_character);
357 } else {
358 put_str(" ");
359 }
360 put_crlf();
361 sprintf(temp, "(bw) Auto-left-margin is %s in the data base",
362 auto_left_margin ? "true" : "false");
363 ptextln(temp);
364 }
365 generic_done_message(t, state, ch);
366}
367
368/*
369** subtest_tbc(test_list, status, ch)
370**
371** test clear tabs (tbc)
372*/
373static void
374subtest_tbc(
375 struct test_list *t,
376 int *state,
377 int *ch)
378{
379 int tabat; /* the tab spacing we end up with */
380 int i;
381
382 if (clear_all_tabs && !set_tab) {
383 ptext("(tbc) Clear-all-tabs is defined but (hts) set-tab is not. ");
384 ptext("Once the tabs are cleared there is no way to set them. ");
385 } else
386 if (clear_all_tabs) {
387 tabat = set_tab ? 8 : init_tabs;
388 tc_putp(clear_all_tabs);
389 ptext("Clear tabs (tbc)");
390 go_home();
391 put_crlf();
392 putchp('\t');
393 putchp('T');
394 go_home();
395 put_newlines(2);
396 for (i = 0; i < columns; i++) {
397 if (i == tabat) {
398 putchp('T');
399 } else {
400 putchp('.');
401 }
402 }
403 go_home();
404 ptext("\n\n\nIf the above two lines have T's in the same column then (tbc) has failed. ");
405 } else {
406 ptext("(tbc) Clear-all-tabs is not defined. ");
407 }
408 generic_done_message(t, state, ch);
409}
410
411/*
412** subtest_hts(test_list, status, ch)
413**
414** (ht) and set tabs with (hts)
415*/
416static void
417subtest_hts(
418 struct test_list *t,
419 int *state,
420 int *ch)
421{
422 int tabat; /* the tab spacing we end up with */
423 int i;
424
425 tabat = init_tabs;
426 if (set_tab) {
427 ptext("Tabs set with (hts)");
428 put_crlf();
429 for (i = 1; i < columns; i++) {
430 if (i % 8 == 1) {
431 tc_putp(set_tab);
432 }
433 putchp(' ');
434 }
435 tabat = 8;
436 } else {
437 sprintf(temp, "(hts) Set-tabs not defined. (it) Initial-tabs at %d", init_tabs);
438 ptext(temp);
439 }
440 go_home();
441 put_newlines(2);
442 if (tabat <= 0) {
443 tabat = 8;
444 }
445 for (i = tabat; i < columns; i += tabat) {
446 putchp('\t');
447 putchp('T');
448 }
449 go_home();
450 put_newlines(3);
451 for (i = 1; i < columns; i++) {
452 putchp('.');
453 }
454 go_home();
455 put_newlines(3);
456 for (i = tabat; i < columns; i += tabat) {
457 putchp('\t');
458 putchp('T');
459 }
460 go_home();
461 put_newlines(4);
462 putchp('.');
463 for (i = 2; i < columns; i++) {
464 if (i % tabat == 1) {
465 putchp('T');
466 } else {
467 putchp('.');
468 }
469 }
470 go_home();
471 put_newlines(5);
472 if (set_tab) {
473 ptextln("If the last two lines are not the same then (hts) has failed.");
474 } else
475 if (init_tabs > 0) {
476 ptextln("If the last two lines are not the same then (it) is wrong.");
477 } else {
478 ptextln("If the last two lines are the same then maybe you do have tabs and (it) should be changed.");
479 }
480 generic_done_message(t, state, ch);
481}
482
483/*
484** subtest_xt(test_list, status, ch)
485**
486** (xt) glitch
487*/
488static void
489subtest_xt(
490 struct test_list *t,
491 int *state,
492 int *ch)
493{
494 int tabat; /* the tab spacing we end up with */
495 int cc;
496
497 tabat = set_tab ? 8 : init_tabs;
498 if (!over_strike && (tabat > 0)) {
499 ptext("(xt) should not ");
500 put_cr();
501 ptext("(xt) should");
502 cc = char_count;
503 while (cc < 16) {
504 putchp('\t');
505 cc = ((cc / tabat) + 1) * tabat;
506 }
507 putln("be set.");
508 sprintf(temp, "(xt) Destructive-tab is %s in the data base.",
509 dest_tabs_magic_smso ? "true" : "false");
510 ptextln(temp);
511 generic_done_message(t, state, ch);
512 }
513}
514
515/*
516** subtest_cbt(test_list, status, ch)
517**
518** (cbt) back tab
519*/
520static void
521subtest_cbt(
522 struct test_list *t,
523 int *state,
524 int *ch)
525{
526 int i;
527
528 if (back_tab) {
529 put_clear();
530 ptext("Back-tab (cbt)");
531 go_home();
532 put_crlf();
533 for (i = 1; i < columns; i++) {
534 putchp(' ');
535 }
536 for (i = 0; i < columns; i += 8) {
537 tc_putp(back_tab);
538 putchp('T');
539 tc_putp(back_tab);
540 }
541 go_home();
542 put_newlines(2);
543 for (i = 1; i < columns; i++) {
544 if (i % 8 == 1) {
545 putchp('T');
546 } else {
547 putchp(' ');
548 }
549 }
550 go_home();
551 put_newlines(3);
552 ptextln("The preceding two lines should be the same.");
553 } else {
554 ptextln("(cbt) Back-tab not present");
555 }
556 generic_done_message(t, state, ch);
557}
558
559/*
560** subtest_xenl(test_list, status, ch)
561**
562** (xenl) eat newline glitch
563*/
564static void
565subtest_xenl(
566 struct test_list *t,
567 int *state,
568 int *ch)
569{
570 int i, j, k;
571
572 if (over_strike) {
573 /* test (xenl) on overstrike terminals */
574 if (!can_go_home || !can_clear_screen) {
575 ptextln("(xenl) Newline-glitch not tested, can't home cursor and clear.");
576 generic_done_message(t, state, ch);
577 return;
578 }
579 put_clear();
580 /*
581 this test must be done in raw mode. Otherwise UNIX will
582 translate CR to CRLF.
583 */
584 if (stty_query(TTY_OUT_TRANS))
585 tty_raw(1, char_mask);
586 ptext("\nreset (xenl). Does ");
587 i = char_count;
588 put_str("not ignore CR, does ");
589 k = char_count;
590 put_str("not ignore LF");
591 go_home();
592 for (j = 0; j < columns; j++)
593 put_this(' ');
594 put_cr();
595 for (j = 0; j < i; j++)
596 putchp(' ');
597 put_str("@@@\n@@");
598 go_home();
599 for (j = 0; j < columns; j++)
600 put_this(' ');
601 put_lf();
602 for (j = 0; j < k; j++)
603 putchp(' ');
604 put_str("@@@\r@@");
605 tty_set();
606 go_home();
607 put_newlines(4);
608 sprintf(temp, "(xenl) Newline-glitch is %s in the data base",
609 eat_newline_glitch ? "true" : "false");
610 ptextln(temp);
611 } else {
612 /* test (xenl) when (os) is reset */
613 if (!can_go_home) {
614 ptextln("(xenl) Newline-glitch not tested, can't home cursor");
615 generic_done_message(t, state, ch);
616 return;
617 }
618 /* (xenl) test */
619 put_clear();
620 /*
621 this test must be done in raw mode. Otherwise
622 UNIX will translate CR to CRLF.
623 */
624 if (stty_query(TTY_OUT_TRANS))
625 tty_raw(1, char_mask);
626 for (j = 0; j < columns; j++)
627 put_this(' ');
628 put_cr();
629 ptext("(xenl) should be set. Does not ignore CR");
630 go_home();
631 put_crlf();
632 for (j = 0; j < columns; j++)
633 put_this(' ');
634 put_lf(); /* test (cud1) */
635 ptext("(xenl) should be set. Ignores (cud1)");
636 go_home();
637 put_newlines(3);
638 if (scroll_forward && cursor_down &&
639 strcmp(scroll_forward, cursor_down)) {
640 for (j = 0; j < columns; j++)
641 put_this(' ');
642 put_ind(); /* test (ind) */
643 ptext("(xenl) should be set. Ignores (ind)");
644 go_home();
645 put_newlines(5);
646 }
647 tty_set();
648 ptextln("If you don't see text above telling you to set it, (xenl) should be false");
649 sprintf(temp, "(xenl) Newline-glitch is %s in the data base",
650 eat_newline_glitch ? "true" : "false");
651 ptextln(temp);
652 }
653 generic_done_message(t, state, ch);
654}
655
656/*
657** subtest_eo(test_list, status, ch)
658**
659** (eo) erase overstrike
660*/
661static void
662subtest_eo(
663 struct test_list *t,
664 int *state,
665 int *ch)
666{
667 if (transparent_underline || over_strike || underline_char) {
668 ptext("(eo) should ");
669 if (underline_char) {
670 ucprint("not");
671 } else {
672 uprint("not");
673 }
674 put_cr();
675 ptextln("(eo) should be set");
676 sprintf(temp, "\n(eo) Erase-overstrike is %s in the data base",
677 erase_overstrike ? "true" : "false");
678 ptextln(temp);
679 generic_done_message(t, state, ch);
680 }
681}
682
683/*
684** subtest_xmc(test_list, status, ch)
685**
686** (xmc) magic cookie glitch
687*/
688static void
689subtest_xmc(
690 struct test_list *t,
691 int *state,
692 int *ch)
693{
694 int i, j;
695
696 if (enter_standout_mode) {
697 sprintf(temp, "\n(xmc) Magic-cookie-glitch is %d in the data base", magic_cookie_glitch);
698 ptextln(temp);
699 j = magic_cookie_glitch * 8;
700 for (i = 0; i < j; i++) {
701 put_str(" ");
702 }
703 ptextln(" These two lines should line up.");
704 if (j > 0) {
705 char_count += j;
706 }
707 for (i = 0; i < 4; i++) {
708 put_mode(enter_standout_mode);
709 putchp(' ');
710 put_mode(exit_standout_mode);
711 putchp(' ');
712 }
713 ptextln("These two lines should line up.");
714 ptext("If they don't line up then (xmc) magic-cookie-glitch should be greater than zero. ");
715 generic_done_message(t, state, ch);
716 }
717}
718
719/*
720** subtest_xhp(test_list, status, ch)
721**
722** (xhp) erase does not clear standout mode
723*/
724static void
725subtest_xhp(
726 struct test_list *t,
727 int *state,
728 int *ch)
729{
730 if (enter_standout_mode) {
731 put_crlf();
732 put_mode(enter_standout_mode);
733 put_str("Stand out");
734 put_mode(exit_standout_mode);
735 put_cr();
736 ptextln("If any part of this line is standout then (xhp) should be set.");
737 sprintf(temp, "(xhp) Erase-standout-glitch is %s in the data base",
738 ceol_standout_glitch ? "true" : "false");
739 ptextln(temp);
740 generic_done_message(t, state, ch);
741 }
742}
743
744/*
745** subtest_mir(test_list, status, ch)
746**
747** (mir) move in insert mode
748*/
749static void
750subtest_mir(
751 struct test_list *t,
752 int *state,
753 int *ch)
754{
755 int i;
756 char *s;
757
758 if (enter_insert_mode && exit_insert_mode && cursor_address) {
759 put_clear();
760 i = line_count;
761 put_str("\nXXX\nXXX\nXXX\nXXX");
762 tc_putp(enter_insert_mode);
763 s = tparm(cursor_address, i + 1, 0);
764 tputs(s, lines, tc_putch);
765 putchp('X');
766 s = tparm(cursor_address, i + 2, 1);
767 tputs(s, lines, tc_putch);
768 putchp('X');
769 s = tparm(cursor_address, i + 3, 2);
770 tputs(s, lines, tc_putch);
771 putchp('X');
772 s = tparm(cursor_address, i + 4, 3);
773 tputs(s, lines, tc_putch);
774 putchp('X');
775 tc_putp(exit_insert_mode);
776 put_newlines(2);
777 ptextln("If you see a 4 by 4 block of X's then (mir) should be true.");
778 sprintf(temp, "(mir) Move-in-insert-mode is %s in the data base",
779 move_insert_mode ? "true" : "false");
780 ptextln(temp);
781 } else {
782 ptext("(mir) Move-in-insert-mode not tested, ");
783 if (!enter_insert_mode) {
784 ptext("(smir) ");
785 }
786 if (!exit_insert_mode) {
787 ptext("(rmir) ");
788 }
789 if (!cursor_address) {
790 ptext("(cup) ");
791 }
792 ptext("not present. ");
793 }
794 generic_done_message(t, state, ch);
795}
796
797/*
798** subtest_msgr(test_list, status, ch)
799**
800** (msgr) move in sgr mode
801*/
802static void
803subtest_msgr(
804 struct test_list *t,
805 int *state,
806 int *ch)
807{
808 int i;
809
810 if (cursor_address &&
811 ((enter_standout_mode && exit_standout_mode) ||
812 (enter_alt_charset_mode && exit_alt_charset_mode))) {
813 put_crlf();
814 i = line_count + 1;
815 tputs(tparm(cursor_address, i, 0), lines, tc_putch);
816 put_mode(enter_alt_charset_mode);
817 put_crlf();
818 /*
819 some versions of the wy-120 can not clear lines or
820 screen when in alt charset mode. If (el) and (ed)
821 are defined then I can test them. If they are not
822 defined then they can not break (msgr)
823 */
824 tc_putp(clr_eos);
825 tc_putp(clr_eol);
826 put_mode(exit_alt_charset_mode);
827 put_mode(enter_standout_mode);
828 putchp('X');
829 tputs(tparm(cursor_address, i + 2, 1), lines, tc_putch);
830 putchp('X');
831 tputs(tparm(cursor_address, i + 3, 2), lines, tc_putch);
832 putchp('X');
833 tputs(tparm(cursor_address, i + 4, 3), lines, tc_putch);
834 putchp('X');
835 put_mode(exit_standout_mode);
836 put_crlf();
837 tc_putp(clr_eos); /* OK if missing */
838 put_crlf();
839 ptextln("If you see a diagonal line of standout X's then (msgr) should be true. If any of the blanks are standout then (msgr) should be false.");
840 sprintf(temp, "(msgr) Move-in-SGR-mode is %s in the data base",
841 move_standout_mode ? "true" : "false");
842 ptextln(temp);
843 } else {
844 ptextln("(smso) (rmso) (smacs) (rmacs) missing; (msgr) Move-in-SGR-mode not tested.");
845 }
846 generic_done_message(t, state, ch);
847}
848
849/*
850** subtest_in(test_list, status, ch)
851**
852** (in) insert null glitch
853*/
854static void
855subtest_in(
856 struct test_list *t,
857 int *state,
858 int *ch)
859{
860 if (enter_insert_mode && exit_insert_mode) {
861 ptextln("\nTesting (in) with (smir) and (rmir)");
862 putln("\tIf these two lines line up ...");
863 put_str("\tIf these two lines line up ...");
864 put_cr();
865 tc_putp(enter_insert_mode);
866 putchp(' ');
867 tc_putp(exit_insert_mode);
868 ptext("\nthen (in) should be set. ");
869 sprintf(temp,
870 "(in) Insert-null-glitch is %s in the data base.",
871 insert_null_glitch ? "true" : "false");
872 ptextln(temp);
873 generic_done_message(t, state, ch);
874 }
875}
876
877/*
878** subtest_dadb(test_list, status, ch)
879**
880** (da) (db) data above, (db) data below
881*/
882static void
883subtest_dadb(
884 struct test_list *t,
885 int *state,
886 int *ch)
887{
888 if (can_clear_screen && scroll_reverse && scroll_forward) {
889 put_clear();
890 if (scroll_reverse)
891 ptext("(da) Data-above should be set\r");
892 home_down();
893 if (scroll_forward)
894 ptext("(db) Data-below should be set\r");
895 tc_putp(scroll_forward);
896 go_home();
897 tc_putp(scroll_reverse);
898 tc_putp(scroll_reverse);
899 home_down();
900 tc_putp(scroll_forward);
901 go_home();
902 ptextln("\n\n\n\n\nIf the top line is blank then (da) should be false.");
903 ptextln("If the bottom line is blank then (db) should be false.");
904 sprintf(temp, "\n(da) Data-above is %s, and (db) Data-below is %s, in the data base.",
905 memory_above ? "true" : "false",
906 memory_below ? "true" : "false");
907 ptextln(temp);
908 line_count = lines;
909 } else {
910 ptextln("(da) Data-above, (db) Data-below not tested, scrolls or (clear) is missing.");
911 }
912 generic_done_message(t, state, ch);
913}
Note: See TracBrowser for help on using the repository browser.