ncurses 5.6 - patch 20061223
[ncurses.git] / tack / modes.c
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
24 MODULE_ID("$Id: modes.c,v 1.3 2006/11/26 00:16:21 tom Exp $")
25
26 /*
27  * Tests boolean flags and terminal modes.
28  */
29 static void subtest_os(struct test_list *, int *, int *);
30 static void subtest_rmam(struct test_list *, int *, int *);
31 static void subtest_smam(struct test_list *, int *, int *);
32 static void subtest_am(struct test_list *, int *, int *);
33 static void subtest_ul(struct test_list *, int *, int *);
34 static void subtest_uc(struct test_list *, int *, int *);
35 static void subtest_bw(struct test_list *, int *, int *);
36 static void subtest_xenl(struct test_list *, int *, int *);
37 static void subtest_eo(struct test_list *, int *, int *);
38 static void subtest_xmc(struct test_list *, int *, int *);
39 static void subtest_xhp(struct test_list *, int *, int *);
40 static void subtest_mir(struct test_list *, int *, int *);
41 static void subtest_msgr(struct test_list *, int *, int *);
42 static void subtest_tbc(struct test_list *, int *, int *);
43 static void subtest_xt(struct test_list *, int *, int *);
44 static void subtest_hts(struct test_list *, int *, int *);
45 static void subtest_cbt(struct test_list *, int *, int *);
46 static void subtest_in(struct test_list *, int *, int *);
47 static void subtest_dadb(struct test_list *, int *, int *);
48
49 struct 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 */
78 static void
79 subtest_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 */
98 static void
99 subtest_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 */
146 static void
147 subtest_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 */
194 static void
195 subtest_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 */
246 static void
247 uprint(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 */
262 static void
263 ucprint(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 */
279 static void
280 subtest_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 */
305 static void
306 subtest_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 */
329 static void
330 subtest_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 */
373 static void
374 subtest_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 */
416 static void
417 subtest_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 */
488 static void
489 subtest_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 */
520 static void
521 subtest_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 */
564 static void
565 subtest_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 */
661 static void
662 subtest_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 */
688 static void
689 subtest_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 */
724 static void
725 subtest_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 */
749 static void
750 subtest_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_2(cursor_address, i + 1, 0);
764                 tputs(s, lines, tc_putch);
765                 putchp('X');
766                 s = TPARM_2(cursor_address, i + 2, 1);
767                 tputs(s, lines, tc_putch);
768                 putchp('X');
769                 s = TPARM_2(cursor_address, i + 3, 2);
770                 tputs(s, lines, tc_putch);
771                 putchp('X');
772                 s = TPARM_2(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 */
802 static void
803 subtest_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_2(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_2(cursor_address, i + 2, 1), lines, tc_putch);
830                 putchp('X');
831                 tputs(TPARM_2(cursor_address, i + 3, 2), lines, tc_putch);
832                 putchp('X');
833                 tputs(TPARM_2(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 */
854 static void
855 subtest_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 */
882 static void
883 subtest_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 }