#include <tack.h>
MODULE_ID("$Id: pad.c,v 1.3 2003/10/18 22:11:29 tom Exp $")
static void pad_standard(struct test_list *, int *, int *);
static void init_xon_xoff(struct test_list *, int *, int *);
static void init_cup(struct test_list *, int *, int *);
static void pad_rmxon(struct test_list *, int *, int *);
static void pad_home1(struct test_list *, int *, int *);
static void pad_home2(struct test_list *, int *, int *);
static void pad_clear(struct test_list *, int *, int *);
static void pad_ech(struct test_list *, int *, int *);
static void pad_el1(struct test_list *, int *, int *);
static void pad_el(struct test_list *, int *, int *);
static void pad_smdc(struct test_list *, int *, int *);
static void pad_dch(struct test_list *, int *, int *);
static void pad_dch1(struct test_list *, int *, int *);
static void pad_smir(struct test_list *, int *, int *);
static void pad_ich(struct test_list *, int *, int *);
static void pad_ich1(struct test_list *, int *, int *);
static void pad_xch1(struct test_list *, int *, int *);
static void pad_rep(struct test_list *, int *, int *);
static void pad_cup(struct test_list *, int *, int *);
static void pad_hd(struct test_list *, int *, int *);
static void pad_hu(struct test_list *, int *, int *);
static void pad_rin(struct test_list *, int *, int *);
static void pad_il(struct test_list *, int *, int *);
static void pad_indn(struct test_list *, int *, int *);
static void pad_dl(struct test_list *, int *, int *);
static void pad_xl(struct test_list *, int *, int *);
static void pad_scrc(struct test_list *, int *, int *);
static void pad_csrind(struct test_list *, int *, int *);
static void pad_sccsrrc(struct test_list *, int *, int *);
static void pad_csr_nel(struct test_list *, int *, int *);
static void pad_csr_cup(struct test_list *, int *, int *);
static void pad_ht(struct test_list *, int *, int *);
static void pad_smso(struct test_list *, int *, int *);
static void pad_smacs(struct test_list *, int *, int *);
static void pad_crash(struct test_list *, int *, int *);
extern struct test_menu change_pad_menu;
const char *pad_repeat_test = {"ep-+<>"};
struct test_list pad_test_list[] = {
{0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu},
{0, 0, 0, 0, "p) change padding", 0, &change_pad_menu},
{0, 0, 0, 0, "@) display statistics about the last test", dump_test_stats, 0},
{0, 0, 0, 0, "c) clear screen", menu_clear_screen, 0},
{0, 0, 0, 0, "i) send reset and init", menu_reset_init, 0},
{0, 0, 0, 0, txt_longer_test_time, longer_test_time, 0},
{0, 0, 0, 0, txt_shorter_test_time, shorter_test_time, 0},
{0, 0, 0, 0, txt_longer_augment, longer_augment, 0},
{0, 0, 0, 0, txt_shorter_augment, shorter_augment, 0},
{MENU_NEXT, 3, "rs1", 0, 0, pad_standard, 0},
{MENU_NEXT, 3, "rs2", 0, 0, pad_standard, 0},
{MENU_NEXT, 3, "rs3", 0, 0, pad_standard, 0},
{MENU_NEXT | MENU_INIT, 0, 0, 0, 0, init_xon_xoff, 0},
{MENU_NEXT, 3, "is1", 0, 0, pad_standard, 0},
{MENU_NEXT, 3, "is2", 0, 0, pad_standard, 0},
{MENU_NEXT, 3, "is3", 0, 0, pad_standard, 0},
{MENU_NEXT, 3, "rmxon", "smxon", 0, pad_rmxon, 0},
{MENU_NEXT | MENU_INIT, 0, 0, 0, 0, init_cup, 0},
{MENU_NEXT, 0, "home", 0, 0, pad_home1, 0},
{MENU_NEXT, 0, "home) (nel", 0, 0, pad_home2, 0},
{MENU_NEXT | 1, 0, "clear", 0, 0, pad_clear, 0},
{MENU_NEXT | MENU_LM1, 0, "ed", 0, 0, pad_clear, 0},
{MENU_NEXT | MENU_80c, 0, "ech", 0, 0, pad_ech, 0},
{MENU_NEXT | MENU_80c, 0, "el1", "cub1 nel", 0, pad_el1, 0},
{MENU_NEXT | MENU_10c, 0, "el", "nel", 0, pad_el, 0},
{MENU_NEXT, 0, "smdc) (rmdc", 0, 0, pad_smdc, 0},
{MENU_NEXT | MENU_80c, 0, "dch", "smdc rmdc", 0, pad_dch, 0},
{MENU_NEXT | MENU_80c, 0, "dch1", "smdc rmdc", 0, pad_dch1, 0},
{MENU_NEXT, 0, "smir) (rmir", 0, 0, pad_smir, 0},
{MENU_NEXT | MENU_90c, 0, "ich) (ip", "smir rmir", 0, pad_ich, 0},
{MENU_NEXT | MENU_90c, 0, "ich1) (ip", "smir rmir", 0, pad_ich1, 0},
{MENU_NEXT, 4, "ich1) (dch1", "smir rmir", 0, pad_xch1, 0},
{MENU_NEXT | MENU_90c, 0, "rep", 0, 0, pad_rep, 0},
{MENU_NEXT, 0, "cup", 0, 0, pad_cup, 0},
{MENU_NEXT, 0, "hd", 0, 0, pad_hd, 0},
{MENU_NEXT, 0, "hu", 0, 0, pad_hu, 0},
{MENU_NEXT | MENU_LM1 | 1, 0, "rin", 0, 0, pad_rin, 0},
{MENU_NEXT, 0, "ri", 0, 0, pad_rin, 0},
{MENU_NEXT | MENU_LM1 | 1, 0, "il", 0, 0, pad_il, 0},
{MENU_NEXT, 0, "il1", 0, 0, pad_il, 0},
{MENU_NEXT | MENU_LM1 | 1, 0, "indn", 0, 0, pad_indn, 0},
{MENU_NEXT, 0, "ind", 0, 0, pad_indn, 0},
{MENU_NEXT | MENU_LM1 | 1, 0, "dl", 0, 0, pad_dl, 0},
{MENU_NEXT, 0, "dl1", 0, 0, pad_dl, 0},
{MENU_NEXT, 0, "il1) (dl1", 0, 0, pad_xl, 0},
{MENU_NEXT, 0, "sc) (rc", 0, 0, pad_scrc, 0},
{MENU_NEXT | MENU_50l, 0, "csr) (ind", 0, 0, pad_csrind, 0},
{MENU_NEXT, 0, "sc) (csr) (rc", 0, 0, pad_sccsrrc, 0},
{MENU_NEXT, 0, "csr) (nel", "sc rc", 0, pad_csr_nel, 0},
{MENU_NEXT, 0, "csr) (cup", 0, 0, pad_csr_cup, 0},
{MENU_NEXT, 0, "ht", 0, 0, pad_ht, 0},
{MENU_NEXT, 0, "smso) (rmso", 0, 0, pad_smso, 0},
{MENU_NEXT, 0, "smacs) (rmacs", 0, 0, pad_smacs, 0},
{MENU_NEXT, 3, "flash", 0, 0, pad_standard, 0},
{MENU_NEXT, 3, "smkx", 0, 0, pad_standard, 0},
{MENU_NEXT, 3, "rmkx", 0, 0, pad_standard, 0},
{MENU_NEXT, 3, "smm", 0, 0, pad_standard, 0},
{MENU_NEXT, 3, "rmm", 0, 0, pad_standard, 0},
{0, 0, "clear", "xon", "k) run clear test with no padding", pad_crash, 0},
{MENU_LAST, 0, 0, 0, 0, 0, 0}
};
extern int test_complete;
int hzcc;
char letter;
int letter_number;
int augment, repeats;
char letters[] = "AbCdefghiJklmNopQrStuVwXyZ";
static char every_line[] = "This text should be on every line.";
static char all_lines[] = "Each char on any line should be the same. ";
static char above_line[] = "The above lines should be all Xs. ";
static char no_visual[] = "This loop test has no visual failure indicator. ";
static void
pad_standard(
struct test_list *t,
int *state,
int *ch)
{
const char *long_name;
char *cap;
int l = 2, i;
char tbuf[128];
if ((cap = get_string_cap_byname(t->caps_done, &long_name))) {
sprintf(tbuf, "(%s) %s, start testing", t->caps_done,
long_name);
if (skip_pad_test(t, state, ch, tbuf)) {
return;
}
i = 1;
pad_test_startup(1);
do {
if (i >= columns) {
page_loop();
l++;
i = 1;
}
tt_putp(cap);
putchp(letter);
i++;
} while(still_testing());
pad_test_shutdown(t, 0);
if (l >= lines) {
home_down();
} else {
put_crlf();
}
ptextln(no_visual);
} else {
CAP_NOT_FOUND;
sprintf(temp, "(%s) %s, not present. ", t->caps_done,
long_name);
ptext(temp);
}
pad_done_message(t, state, ch);
}
static void
init_xon_xoff(
struct test_list *t GCC_UNUSED,
int *state GCC_UNUSED,
int *ch GCC_UNUSED)
{
if (select_xon_xoff == 0 && exit_xon_mode) {
tc_putp(exit_xon_mode);
}
if (select_xon_xoff == 1 && enter_xon_mode) {
tc_putp(enter_xon_mode);
}
}
static void
pad_rmxon(
struct test_list *t,
int *state,
int *ch)
{
if (select_xon_xoff == 0 && exit_xon_mode) {
pad_standard(t, state, ch);
}
}
static void
init_cup(
struct test_list *t,
int *state,
int *ch)
{
init_xon_xoff(t, state, ch);
if (enter_ca_mode) {
tc_putp(enter_ca_mode);
}
if (!can_clear_screen) {
ptext("(clear) clear screen not present,");
ptext(" pad processing terminated. ");
pad_done_message(t, state, ch);
if (*ch == 0 || *ch == 'n' || *ch == 's' || *ch == 'r') {
*ch = '?';
}
return;
}
}
static void
pad_home1(
struct test_list *t,
int *state,
int *ch)
{
int j, k;
if (can_go_home && auto_right_margin) {
if (skip_pad_test(t, state, ch, "(home) Home start testing")) {
return;
}
pad_test_startup(1);
do {
go_home();
for (j = 1; j < lines; j++) {
for (k = 0; k < columns; k++) {
if (k & 0xF) {
put_this(letter);
} else {
put_this('.');
}
}
SLOW_TERMINAL_EXIT;
}
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 0);
ptext("All the dots should line up. ");
pad_done_message(t, state, ch);
put_clear();
}
}
static void
pad_home2(
struct test_list *t,
int *state,
int *ch)
{
int j, k;
if (can_go_home) {
if (skip_pad_test(t, state, ch,
"(home) Home, (nel) newline start testing")) {
return;
}
pad_test_startup(1);
do {
go_home();
for (j = 1; j < lines; j++) {
for (k = 2; k < columns; k++) {
if (k & 0xF) {
put_this(letter);
} else {
put_this('.');
}
}
put_crlf();
SLOW_TERMINAL_EXIT;
}
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 0);
ptext("All the dots should line up. ");
pad_done_message(t, state, ch);
put_clear();
}
}
static void
pad_clear(
struct test_list *t,
int *state,
int *ch)
{
const char *end_message = 0;
const char *txt;
int j, k, is_clear;
int clear_select;
is_clear = t->flags & 1;
clear_select = auto_right_margin ? 0 : 1;
if (is_clear) {
txt = "(clear) clear-screen start testing";
} else {
if (!clr_eos) {
CAP_NOT_FOUND;
ptext("(ed) erase-to-end-of-display, not present. ");
pad_done_message(t, state, ch);
return;
}
txt = "(ed) erase-to-end-of-display start testing";
}
if (skip_pad_test(t, state, ch, txt)) {
return;
}
if (enter_am_mode) {
tc_putp(enter_am_mode);
clear_select = 0;
}
for (; clear_select < 5; clear_select++) {
if (augment > lines || is_clear || !cursor_address) {
augment = lines;
} else {
if (augment <= 1) {
augment = 2;
}
if (augment < lines) {
put_clear();
tt_putparm(cursor_address, 1,
lines - augment - 1, 0);
ptextln("This line should not be erased (ed)");
}
}
repeats = augment;
switch (clear_select) {
case 0:
end_message = "Clear full screen. ";
break;
case 1:
end_message = "Clear sparse screen. ";
if (cursor_down) {
break;
}
clear_select++;
case 2:
end_message = "Clear one character per line. ";
if (newline) {
break;
}
clear_select++;
case 3:
end_message = "Clear one full line. ";
break;
case 4:
end_message = "Clear single short line. ";
break;
}
pad_test_startup(0);
do {
switch (clear_select) {
case 0:
for (j = 1; j < repeats; j++) {
for (k = 0; k < columns; k++) {
if (k & 0xF) {
put_this(letter);
} else {
put_this('.');
}
}
SLOW_TERMINAL_EXIT;
}
break;
case 1:
for (j = columns - repeats; j > 2; j--) {
put_this(letter);
}
for (j = 2; j < repeats; j++) {
tt_putp(cursor_down);
put_this(letter);
}
break;
case 2:
for (j = 2; j < repeats; j++) {
put_this(letter);
tt_putp(newline);
}
put_this(letter);
break;
case 3:
for (j = columns - 5; j > 1; j--) {
put_this(letter);
}
break;
case 4:
put_str("Erase this!");
break;
}
if (is_clear) {
put_clear();
} else {
if (augment == lines) {
go_home();
} else {
tt_putparm(cursor_address, 1,
lines - repeats, 0);
}
tt_tputs(clr_eos, repeats);
}
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 1);
ptext(end_message);
pad_done_message(t, state, ch);
if (*ch != 0 && *ch != 'n') {
return;
}
}
}
static void
pad_ech(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!erase_chars) {
CAP_NOT_FOUND;
ptext("(ech) Erase-characters, not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(ech) Erase-characters start testing")) {
return;
}
if (augment > columns - 2) {
augment = columns - 2;
}
pad_test_startup(1);
do {
go_home();
for (i = 2; i < lines; i++) {
for (j = 0; j <= repeats; j++) {
putchp(letter);
}
put_cr();
tt_putparm(erase_chars, repeats, repeats, 0);
put_crlf();
SLOW_TERMINAL_EXIT;
}
for (i = 1; i <= repeats; i++) {
putchp(' ');
}
putchp(letter);
put_crlf();
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 0);
ptext(all_lines);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_el1(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!clr_bol) {
CAP_NOT_FOUND;
ptext("(el1) Erase-to-beginning-of-line, not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(el1) Erase-to-beginning-of-line start testing")) {
return;
}
if (augment > columns - 2) {
augment = columns - 2;
}
pad_test_startup(1);
do {
go_home();
for (i = 2; i < lines; i++) {
for (j = 0; j <= repeats; j++) {
putchp(letter);
}
tt_putp(cursor_left);
tt_putp(cursor_left);
tt_tputs(clr_bol, repeats);
put_crlf();
SLOW_TERMINAL_EXIT;
}
for (i = 1; i <= repeats; i++) {
putchp(' ');
}
putchp(letter);
put_crlf();
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 0);
ptext(all_lines);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_el(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!clr_eol) {
CAP_NOT_FOUND;
ptext("(el) Clear-to-end-of-line, not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(el) Clear-to-end-of-line start testing")) {
return;
}
hzcc = columns * 8 / 10;
if (augment > hzcc) {
augment = hzcc;
}
pad_test_startup(1);
do {
go_home();
for (i = 2; i < lines; i++) {
for (j = -1; j < augment; j++) {
putchp(letter);
}
put_cr();
putchp(letter);
tt_putp(clr_eol);
put_crlf();
SLOW_TERMINAL_EXIT;
}
putchp(letter);
put_crlf();
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 0);
ptext(all_lines);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_smdc(
struct test_list *t,
int *state,
int *ch)
{
int i;
if (!enter_delete_mode) {
CAP_NOT_FOUND;
ptext("(smdc) Enter-delete-mode");
if (!exit_delete_mode) {
ptext(", (rmdc) Exit-delete-mode");
}
ptext(", not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(smdc) (rmdc) Enter/Exit-delete-mode start testing")) {
return;
}
pad_test_startup(1);
do {
page_loop();
for (i = 1; i < columns; i++) {
tt_putp(enter_delete_mode);
tt_putp(exit_delete_mode);
putchp(letter);
}
} while(still_testing());
pad_test_shutdown(t, 0);
home_down();
ptext(no_visual);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_dch(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!parm_dch) {
CAP_NOT_FOUND;
ptext("(dch) Delete-characters, not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(dch) Delete-characters start testing")) {
return;
}
hzcc = columns * 8 / 10;
if (augment > hzcc) {
augment = hzcc;
}
pad_test_startup(1);
do {
go_home();
for (i = 2; i < lines; i++) {
for (j = 0; j <= repeats; j++) {
putchp(letter);
}
put_cr();
tt_putp(enter_delete_mode);
tt_putparm(parm_dch, repeats, repeats, 0);
tt_putp(exit_delete_mode);
put_crlf();
SLOW_TERMINAL_EXIT;
}
putchp(letter);
put_crlf();
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 0);
home_down();
ptext(all_lines);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_dch1(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!delete_character) {
if (parm_dch) {
return;
}
CAP_NOT_FOUND;
ptext("(dch1) Delete-character, not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(dch1) Delete-character start testing")) {
return;
}
hzcc = columns * 8 / 10;
if (augment > hzcc) {
augment = hzcc;
}
pad_test_startup(1);
do {
go_home();
for (i = 2; i < lines; i++) {
for (j = -1; j < augment; j++) {
putchp(letter);
}
put_cr();
tt_putp(enter_delete_mode);
for (j = 0; j < augment; j++) {
tt_putp(delete_character);
}
tt_putp(exit_delete_mode);
put_crlf();
SLOW_TERMINAL_EXIT;
}
putchp(letter);
put_crlf();
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 0);
ptext(all_lines);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_smir(
struct test_list *t,
int *state,
int *ch)
{
int i;
if (!enter_insert_mode) {
CAP_NOT_FOUND;
ptext("(smir) Enter-insert-mode");
if (!exit_insert_mode) {
ptext(", (rmir) Exit-insert-mode");
}
ptext(", not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(smir) (rmir) Enter/Exit-insert-mode start testing")) {
return;
}
pad_test_startup(1);
do {
page_loop();
for (i = 1; i < columns; i++) {
tt_putp(enter_insert_mode);
tt_putp(exit_insert_mode);
putchp(letter);
}
} while(still_testing());
pad_test_shutdown(t, 0);
home_down();
ptext(no_visual);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_ich(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!parm_ich) {
CAP_NOT_FOUND;
ptext("(ich) Insert-characters, not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(ich) Insert-characters, (ip) Insert-padding start testing")) {
return;
}
j = columns * 9 / 10;
if (augment > j) {
augment = j;
}
pad_test_startup(1);
do {
go_home();
for (i = 2; i < lines; i++) {
putchp(letter);
put_cr();
tt_putp(enter_insert_mode);
replace_mode = 0;
tt_putparm(parm_ich, repeats, repeats, 0);
tt_putp(exit_insert_mode);
replace_mode = 1;
put_crlf();
SLOW_TERMINAL_EXIT;
}
for (i = 0; i < repeats; i++) {
putchp(' ');
}
putchp(letter);
NEXT_LETTER;
put_crlf();
} while(still_testing());
pad_test_shutdown(t, 0);
ptext(all_lines);
pad_done_message(t, state, ch);
tc_putp(exit_insert_mode);
}
static void
pad_ich1(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!insert_character) {
CAP_NOT_FOUND;
ptext("(ich1) Insert-character, not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(ich1) Insert-character, (ip) Insert-padding start testing")) {
return;
}
if (augment > columns - 2) {
augment = columns - 2;
}
pad_test_startup(1);
do {
put_clear();
for (i = 2; i < lines; i++) {
putchp(letter);
put_cr();
tt_putp(enter_insert_mode);
replace_mode = 0;
if (!insert_padding && !insert_character) {
for (j = 0; j < augment; j++) {
putchp('.');
}
} else {
for (j = 0; j < augment; j++) {
tt_putp(insert_character);
putchp('.');
tt_putp(insert_padding);
}
}
tt_putp(exit_insert_mode);
replace_mode = 1;
put_crlf();
SLOW_TERMINAL_EXIT;
}
for (j = 0; j < augment; j++) {
putchp('.');
}
putchp(letter);
NEXT_LETTER;
put_crlf();
} while(still_testing());
pad_test_shutdown(t, 0);
ptext(all_lines);
pad_done_message(t, state, ch);
tc_putp(exit_insert_mode);
}
static void
pad_xch1(
struct test_list *t,
int *state,
int *ch)
{
static char xch1[] =
"This line should not be garbled. It should be left justified.";
if (enter_insert_mode || exit_insert_mode ||
enter_delete_mode || exit_delete_mode ||
!insert_character || !delete_character) {
return;
}
if (skip_pad_test(t, state, ch,
"(ich1) Insert-character, (dch1) Delete-character start testing")) {
return;
}
put_crlf();
ptext(xch1);
put_cr();
pad_test_startup(0);
do {
tt_putp(insert_character);
tt_putp(delete_character);
} while(still_testing());
pad_test_shutdown(t, 1);
ptextln(xch1);
ptext("The preceding two lines should be the same. ");
pad_done_message(t, state, ch);
}
static void
pad_rep(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!repeat_char) {
CAP_NOT_FOUND;
ptext("(rep) Repeat-character, not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(rep) Repeat-character start testing")) {
return;
}
if (augment > columns - 2) {
augment = columns - 2;
}
if (augment < 2) {
augment = 2;
}
pad_test_startup(1);
do {
go_home();
for (i = 2; i < lines; i++) {
tt_putparm(repeat_char, repeats, letter, repeats);
put_crlf();
}
for (j = 0; j < repeats; j++) {
putchp(letter);
}
put_crlf();
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 0);
ptextln(all_lines);
pad_done_message(t, state, ch);
}
static void
pad_cup(
struct test_list *t,
int *state,
int *ch)
{
int i, j, l, r, c;
if (!cursor_address) {
CAP_NOT_FOUND;
ptext("(cup) Cursor-address not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(cup) Cursor-address start testing")) {
return;
}
put_clear();
ptext("Each line should be filled with the same letter. There should");
ptext(" be no gaps, or single letters scattered over the screen. ");
if (char_count + 15 > columns) {
put_crlf();
}
if (((lines - line_count) & 1) == 0) {
put_crlf();
}
r = line_count;
c = char_count;
l = (columns - 4) >> 1;
pad_test_startup(0);
do {
for (i = 1; i + i + r < lines; i++) {
for (j = 0; j <= l; j++) {
tt_putparm(cursor_address, 1, r + i, j);
putchp(letter);
tt_putparm(cursor_address, 1, r + i, l + l + 1 - j);
putchp(letter);
tt_putparm(cursor_address, 1, lines - i, j);
putchp(letter);
tt_putparm(cursor_address, 1, lines - i, l + l + 1 - j);
putchp(letter);
}
SLOW_TERMINAL_EXIT;
}
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 0);
tt_putparm(cursor_address, 1, line_count = r, char_count = c);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_hd(
struct test_list *t,
int *state,
int *ch)
{
int i, j, k;
if (!down_half_line) {
CAP_NOT_FOUND;
ptext("(hd) Half-line-down not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(hd) Half-line-down start testing")) {
return;
}
pad_test_startup(1);
do {
for (i = 1; i < columns; i += 2) {
for (j = 1; j < i; ++j) {
putchp(' ');
}
tt_putp(down_half_line);
for (k = lines + lines; k > 4; k--) {
if (j++ >= columns) {
break;
}
tt_putp(down_half_line);
putchp(letter);
}
go_home();
SLOW_TERMINAL_EXIT;
}
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 0);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_hu(
struct test_list *t,
int *state,
int *ch)
{
int i, j, k;
if (!up_half_line) {
CAP_NOT_FOUND;
ptext("(hu) Half-line-up not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(hu) Half-line-up start testing")) {
return;
}
pad_test_startup(1);
do {
for (i = 1; i < columns; i += 2) {
home_down();
for (j = 1; j < i; ++j) {
putchp(' ');
}
tt_putp(up_half_line);
for (k = lines + lines; k > 4; k--) {
if (j++ >= columns) {
break;
}
tt_putp(up_half_line);
putchp(letter);
}
SLOW_TERMINAL_EXIT;
}
go_home();
NEXT_LETTER;
} while(still_testing());
pad_test_shutdown(t, 0);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_rin(
struct test_list *t,
int *state,
int *ch)
{
int i;
const char *start_message;
if (t->flags & 1) {
if (!parm_rindex) {
CAP_NOT_FOUND;
ptext("(rin) Scroll-reverse-n-lines not present. ");
pad_done_message(t, state, ch);
return;
}
start_message = "(rin) Scroll-reverse-n-lines start testing";
} else {
if (!scroll_reverse) {
CAP_NOT_FOUND;
ptext("(ri) Scroll-reverse not present. ");
pad_done_message(t, state, ch);
return;
}
start_message = "(ri) Scroll-reverse start testing";
augment = 1;
}
if (skip_pad_test(t, state, ch, start_message)) {
return;
}
pad_test_startup(1);
do {
sprintf(temp, "%d\r", test_complete);
put_str(temp);
if (scroll_reverse && repeats == 1) {
tt_putp(scroll_reverse);
} else {
tt_putparm(parm_rindex, repeats, repeats, 0);
}
} while(still_testing());
put_str("This line should be on the bottom.\r");
if (scroll_reverse && augment == 1) {
for (i = 1; i < lines; i++) {
tt_putp(scroll_reverse);
}
} else {
tt_putparm(parm_rindex, lines - 1, lines - 1, 0);
}
putln("The screen should have text on the bottom line.");
sprintf(temp, "Scroll reverse %d line%s. ", augment,
augment == 1 ? "" : "s");
put_str(temp);
pad_test_shutdown(t, 0);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_il(
struct test_list *t,
int *state,
int *ch)
{
int i;
const char *start_message;
if (t->flags & 1) {
if (!parm_insert_line) {
CAP_NOT_FOUND;
ptext("(il) Insert-lines not present. ");
pad_done_message(t, state, ch);
return;
}
start_message = "(il) Insert-lines start testing";
} else {
if (!insert_line) {
CAP_NOT_FOUND;
ptext("(il1) Insert-line not present. ");
pad_done_message(t, state, ch);
return;
}
start_message = "(il1) Insert-line start testing";
augment = 1;
}
if (skip_pad_test(t, state, ch, start_message)) {
return;
}
pad_test_startup(1);
do {
sprintf(temp, "%d\r", test_complete);
put_str(temp);
if (insert_line && repeats == 1) {
tt_putp(insert_line);
} else {
tt_putparm(parm_insert_line, repeats, repeats, 0);
}
} while(still_testing());
put_str("This line should be on the bottom.\r");
if (insert_line && augment == 1) {
for (i = 1; i < lines; i++) {
tt_putp(insert_line);
}
} else {
tt_putparm(parm_insert_line, lines - 1, lines - 1, 0);
}
putln("The screen should have text on the bottom line.");
sprintf(temp, "Insert %d line%s. ", augment,
augment == 1 ? "" : "s");
put_str(temp);
pad_test_shutdown(t, 0);
pad_done_message(t, state, ch);
put_clear();
}
static void
pad_indn(
struct test_list *t,
int *state,
int *ch)
{
int i;
const char *start_message;
if (t->flags & 1) {
if (!parm_index) {
CAP_NOT_FOUND;
ptext("(indn) Scroll-forward-n-lines not present. ");
pad_done_message(t, state, ch);
return;
}
start_message = "(indn) Scroll-forward-n-lines start testing";
} else {
if (!scroll_forward) {
CAP_NOT_FOUND;
ptext("(ind) Scroll-forward not present. ");
pad_done_message(t, state, ch);
return;
}
if (over_strike) {
ptext("(ind) Scroll-forward not tested on overstrike terminals. ");
pad_done_message(t, state, ch);
return;
}
start_message = "(ind) Scroll-forward start testing";
augment = 1;
}
if (skip_pad_test(t, state, ch, start_message)) {
return;
}
pad_test_startup(1);
home_down();
do {
sprintf(temp, "%d\r", test_complete);
put_str(temp);
if (scroll_forward && repeats == 1) {
put_ind();
} else {
tt_putparm(parm_index, repeats, repeats, 0);
}
} while(still_testing());
put_str("This line should be on the top.\r");
if (scroll_forward && augment == 1) {
for (i = 1; i < lines; i++) {
put_ind();
}
} else {
tt_putparm(parm_index, lines - 1, lines - 1, 0);
}
go_home();
sprintf(temp, "\nScroll forward %d line%s. ", augment,
augment == 1 ? "" : "s");
put_str(temp);
pad_test_shutdown(t, 0);
pad_done_message(t, state, ch);
}
static void
pad_dl(
struct test_list *t,
int *state,
int *ch)
{
int i = 0;
const char *start_message;
if (t->flags & 1) {
if (!parm_delete_line) {
CAP_NOT_FOUND;
ptext("(dl) Delete-lines not present. ");
pad_done_message(t, state, ch);
return;
}
start_message = "(dl) Delete-lines start testing";
} else {
if (!delete_line) {
CAP_NOT_FOUND;
ptext("(dl1) Delete-line not present. ");
pad_done_message(t, state, ch);
return;
}
start_message = "(dl1) Delete-line start testing";
augment = 1;
}
if (skip_pad_test(t, state, ch, start_message)) {
return;
}
pad_test_startup(1);
do {
sprintf(temp, "%d\r", test_complete);
if (augment < lines - 1) {
go_home();
putln(temp);
}
put_str(temp);
if (delete_line && repeats == 1) {
tt_putp(delete_line);
} else {
tt_putparm(parm_delete_line, repeats, repeats, 0);
}
} while(still_testing());
home_down();
put_str("This line should be on the top.");
go_home();
if (delete_line && augment == 1) {
for (i = 1; i < lines; i++) {
tt_putp(delete_line);
}
} else {
tt_putparm(parm_delete_line, lines - 1, lines - 1, 0);
}
sprintf(temp, "\nDelete %d line%s. ", augment,
augment == 1 ? "" : "s");
put_str(temp);
pad_test_shutdown(t, 0);
pad_done_message(t, state, ch);
}
static void
pad_xl(
struct test_list *t,
int *state,
int *ch)
{
if (!insert_line && !delete_line) {
return;
}
if (skip_pad_test(t, state, ch,
"(il1) Insert-line, (dl1) Delete-line start testing")) {
return;
}
put_clear();
putln("\rThis text is written on the first line.");
ptext("This sentence begins on the second line. As this");
ptext(" test runs the bottom part of this paragraph will");
ptext(" jump up and down. Don't worry, that's normal. When");
ptext(" the jumping stops, the entire paragraph should");
ptext(" still be on the screen and in the same place as when");
ptext(" the test started. If this paragraph has scrolled");
ptext(" off the top or bottom of the screen then the test");
ptext(" has failed. Scrolling off the top of the screen");
ptext(" usually means that the delete line capability is");
ptext(" working better than the insert line capability. If");
ptext(" the text scrolls off the bottom then delete line may");
ptext(" be broken. If parts of the text are missing then");
ptext(" you should get professional help.");
put_crlf();
go_home();
put_newlines(2);
pad_test_startup(0);
do {
tt_putp(insert_line);
put_cr();
tt_putp(delete_line);
} while(still_testing());
pad_test_shutdown(t, 0);
home_down();
ptext("The top of the screen should have a paragraph of text. ");
pad_done_message(t, state, ch);
}
static void
pad_scrc(
struct test_list *t,
int *state,
int *ch)
{
int i;
if (!save_cursor || !restore_cursor) {
CAP_NOT_FOUND;
if (save_cursor) {
ptext("(rc) Restore-cursor");
} else
if (restore_cursor) {
ptext("(sc) Save-cursor");
} else {
ptext("(sc) Save-cursor, (rc) Restore-cursor");
}
ptext(" not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(sc) (rc) Save/Restore-cursor start testing")) {
return;
}
pad_test_startup(1);
do {
page_loop();
for (i = 1; i < columns; i++) {
tt_putp(save_cursor);
putchp(letter);
tt_putp(restore_cursor);
putchp('X');
}
} while(still_testing());
pad_test_shutdown(t, 0);
home_down();
ptext(above_line);
pad_done_message(t, state, ch);
}
static void
pad_csrind(
struct test_list *t,
int *state,
int *ch)
{
int i;
if (!change_scroll_region) {
CAP_NOT_FOUND;
ptext("(csr) Change-scroll-region not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(csr) Save/Restore-cursor, (ind) index start testing")) {
return;
}
if (augment < 2) {
augment = 2;
}
if (augment > lines - 1) {
augment = lines - 1;
}
put_clear();
ptext("This text is on the top line.");
tt_putparm(change_scroll_region, 1, lines - augment, lines - 1);
home_down();
pad_test_startup(0);
do {
sprintf(temp, "%d\r", test_complete);
put_str(temp);
put_ind();
} while(still_testing());
ptextln("(csr) is broken.");
for (i = augment; i > 1; i--) {
put_ind();
}
pad_test_shutdown(t, 0);
ptext("All but top and bottom lines should be blank. ");
pad_done_message(t, state, ch);
tt_putparm(change_scroll_region, 1, 0, lines - 1);
put_clear();
}
static void
pad_sccsrrc(
struct test_list *t,
int *state,
int *ch)
{
int i;
if (!save_cursor || !change_scroll_region || !restore_cursor) {
return;
}
if (skip_pad_test(t, state, ch,
"(sc) (csr) (rc) Save/Change/Restore-cursor, start testing")) {
return;
}
pad_test_startup(1);
do {
page_loop();
for (i = 1; i < columns; i++) {
tt_putp(save_cursor);
putchp(letter);
tt_putparm(change_scroll_region, 1, 0, lines - 1);
tt_putp(restore_cursor);
putchp('X');
}
} while(still_testing());
pad_test_shutdown(t, 0);
home_down();
ptext(above_line);
pad_done_message(t, state, ch);
tt_putparm(change_scroll_region, 1, 0, lines - 1);
}
static void
pad_csr_nel(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!save_cursor || !change_scroll_region || !restore_cursor) {
return;
}
if (skip_pad_test(t, state, ch,
"(csr) Change-scroll-region, (nel) newline start testing")) {
return;
}
pad_test_startup(1);
do {
for (i = 0; i < lines; i++) {
for (j = lines - i; j > 0; j--) {
put_crlf();
}
tt_putp(save_cursor);
tt_putparm(change_scroll_region, 1, i, lines - 1);
tt_putp(restore_cursor);
put_str(every_line);
}
tt_putp(save_cursor);
tt_putparm(change_scroll_region, 1, 0, lines - 1);
tt_putp(restore_cursor);
} while(still_testing());
pad_test_shutdown(t, 0);
put_str(" ");
pad_done_message(t, state, ch);
tt_putparm(change_scroll_region, 1, 0, lines - 1);
}
static void
pad_csr_cup(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!change_scroll_region || !cursor_address) {
return;
}
if (skip_pad_test(t, state, ch,
"(csr) Change-scroll-region, (cup) cursor-address start testing")) {
return;
}
pad_test_startup(1);
do {
for (i = 0; i < lines; i++) {
for (j = lines - i; j > 0; j--) {
put_crlf();
}
tt_putparm(change_scroll_region, 1, i, lines - 1);
tt_putparm(cursor_address, 1, lines - 1, 0);
put_str(every_line);
}
tt_putparm(change_scroll_region, 1, 0, lines - 1);
tt_putparm(cursor_address, 1, lines - 1, strlen(every_line));
} while(still_testing());
pad_test_shutdown(t, 0);
put_str(" ");
pad_done_message(t, state, ch);
tt_putparm(change_scroll_region, 1, 0, lines - 1);
}
static void
pad_ht(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!set_tab && init_tabs <= 0) {
CAP_NOT_FOUND;
ptext("(ht) Tab not tested. (hts) Set-tabs and (it) initial-tabs not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch, "(ht) Tab start testing")) {
return;
}
pad_test_startup(1);
do {
if (auto_right_margin && can_go_home)
for (i = 1, go_home(); i < lines - 2; i++) {
for (j = 8; j < columns; j += 8) {
putchp('\t');
}
put_str("A ");
}
if (cursor_down && can_go_home)
for (i = 1, go_home(); i < lines - 2; i++) {
for (j = 8; j < columns; j += 8) {
putchp('\t');
}
put_str("D\r");
tt_putp(cursor_down);
}
if (cursor_address)
for (i = 1; i < lines - 2; i++) {
tt_putparm(cursor_address, 1, i - 1, 0);
for (j = 8; j < columns; j += 8) {
putchp('\t');
}
put_str("C");
}
go_home();
for (i = 1; i < lines - 2; i++) {
for (j = 8; j < columns; j += 8) {
putchp('\t');
}
putln("N");
}
} while(still_testing());
pad_test_shutdown(t, 0);
ptextln("Letters on the screen other than Ns at the right margin indicate failure.");
ptext("A-(am) D-(cud1) C-(cup) N-(nel) ");
pad_done_message(t, state, ch);
}
static void
pad_smso(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!enter_standout_mode || !exit_standout_mode) {
CAP_NOT_FOUND;
ptext("(smso) (rmso) Enter/Exit-standout-mode not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(smso) (rmso) Enter/Exit-standout-mode start testing")) {
return;
}
pad_test_startup(1);
do {
page_loop();
j = magic_cookie_glitch > 0 ? magic_cookie_glitch : 0;
for (i = 2 + j + j; i < columns;) {
put_mode(enter_standout_mode);
i += j + j + 2;
putchp('X');
put_mode(exit_standout_mode);
putchp('X');
}
} while(still_testing());
pad_test_shutdown(t, 0);
home_down();
ptext(above_line);
pad_done_message(t, state, ch);
put_mode(exit_standout_mode);
}
static void
pad_smacs(
struct test_list *t,
int *state,
int *ch)
{
int i, j;
if (!enter_alt_charset_mode) {
CAP_NOT_FOUND;
ptext("(smacs) Enter-altcharset-mode not present. ");
pad_done_message(t, state, ch);
return;
}
if (skip_pad_test(t, state, ch,
"(smacs) (rmacs) Enter/Exit-altcharset-mode start testing")) {
return;
}
pad_test_startup(1);
do {
page_loop();
j = magic_cookie_glitch > 0 ? magic_cookie_glitch : 0;
for (i = 2 + j + j; i < columns;) {
put_mode(enter_alt_charset_mode);
i += j + j + 2;
putchp(letter);
put_mode(exit_alt_charset_mode);
putchp(letter);
}
} while(still_testing());
pad_test_shutdown(t, 0);
home_down();
ptext("Every other character is from the alternate character set. ");
pad_done_message(t, state, ch);
put_mode(exit_alt_charset_mode);
}
static void
pad_crash(
struct test_list *t,
int *state,
int *ch)
{
int save_xon_xoff;
if (!clear_screen) {
ptext("(clear) Clear-screen not present. ");
pad_done_message(t, state, ch);
return;
}
ptext("If you would like to see if the terminal will really lock up.");
ptextln(" I will send the clear screen sequence without the pads.");
if (skip_pad_test(t, state, ch,
"(clear) Clear-screen start crash testing")) {
return;
}
save_xon_xoff = xon_xoff;
xon_xoff = 1;
pad_test_startup(0);
do {
put_str("Erase this!");
tt_putp(clear_screen);
} while(still_testing());
xon_xoff = save_xon_xoff;
pad_test_shutdown(t, 1);
pad_done_message(t, state, ch);
}