nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-01-09 17:38:00 +00:00
Code Issues Projects Releases Wiki Activity
f58ddf26fe
putty-source/test/test_lineedit.c
Simon Tatham 363debc7f0 lineedit: make both ^M and ^J terminate a line. 
In protocols other than PROT_RAW, the new line editing system differed
from the old one in not considering ^M or ^J (typed using the actual
Ctrl key, so distinct from pressing Return) to mean "I've finished
editing this line, please send it". This commit reinstates that
behaviour.

It turned out that a third-party tool (namely PuTTY Connection Manager),
which automatically answers prompts for the user, was terminating them
by sending ^J in place of the Return key. We don't know why (and it's
now unmaintained), but it was. So this change should make that tool
start working again.

I exclude PROT_RAW above because in that protocol the line editing has
much weirder handling for ^M and ^J, which lineedit replicated
faithfully from the old code: either control character by itself is
treated literally (displaying as "^M" or "^J" in the terminal), but if
you type the two in sequence in that order, then the ^J deletes the ^M
from the edit buffer and enters the line, so that the sequence CR LF
acts as a newline overall. I haven't changed that behaviour here, but
I have added a regression test of it to test_lineedit.
2024-12-15 19:23:21 +00:00

833 lines
28 KiB
C
Raw Blame History

#include "putty.h"
#include "terminal.h"
void modalfatalbox(const char *p, ...)
{
va_list ap;
fprintf(stderr, "FATAL ERROR: ");
va_start(ap, p);
vfprintf(stderr, p, ap);
va_end(ap);
fputc('\n', stderr);
exit(1);
}
const char *const appname = "test_lineedit";
char *platform_default_s(const char *name)
{ return NULL; }
bool platform_default_b(const char *name, bool def)
{ return def; }
int platform_default_i(const char *name, int def)
{ return def; }
FontSpec *platform_default_fontspec(const char *name)
{ return fontspec_new_default(); }
Filename *platform_default_filename(const char *name)
{ return filename_from_str(""); }
struct SpecialRecord {
SessionSpecialCode code;
int arg;
};
typedef struct Mock {
Terminal *term;
Ldisc *ldisc;
Conf *conf;
struct unicode_data ucsdata[1];
bool echo, edit;
strbuf *to_terminal, *to_backend;
struct SpecialRecord *specials;
size_t nspecials, specialsize;
strbuf *context; /* for printing in failed tests */
bool any_test_failed;
TermWin tw;
Seat seat;
Backend backend;
} Mock;
static size_t mock_output(Seat *seat, SeatOutputType type,
const void *data, size_t len)
{
Mock *mk = container_of(seat, Mock, seat);
put_data(mk->to_terminal, data, len);
return 0;
}
static void mock_send(Backend *be, const char *buf, size_t len)
{
Mock *mk = container_of(be, Mock, backend);
put_data(mk->to_backend, buf, len);
}
static void mock_special(Backend *be, SessionSpecialCode code, int arg)
{
Mock *mk = container_of(be, Mock, backend);
sgrowarray(mk->specials, mk->specialsize, mk->nspecials);
mk->specials[mk->nspecials].code = code;
mk->specials[mk->nspecials].arg = arg;
mk->nspecials++;
}
static bool mock_ldisc_option_state(Backend *be, int option)
{
Mock *mk = container_of(be, Mock, backend);
switch (option) {
case LD_ECHO:
return mk->echo;
case LD_EDIT:
return mk->edit;
default:
unreachable("bad ldisc option");
}
}
static void mock_provide_ldisc(Backend *be, Ldisc *ldisc)
{
Mock *mk = container_of(be, Mock, backend);
mk->ldisc = ldisc;
}
static bool mock_sendok(Backend *be)
{
Mock *mk = container_of(be, Mock, backend);
(void)mk;
/* FIXME: perhaps make this settable, to test the input_queue system? */
return true;
}
static void mock_set_raw_mouse_mode(TermWin *win, bool enable) {}
static void mock_palette_get_overrides(TermWin *tw, Terminal *term) {}
static const TermWinVtable mock_termwin_vt = {
.set_raw_mouse_mode = mock_set_raw_mouse_mode,
.palette_get_overrides = mock_palette_get_overrides,
};
static const SeatVtable mock_seat_vt = {
.output = mock_output,
.echoedit_update = nullseat_echoedit_update,
};
static const BackendVtable mock_backend_vt = {
.sendok = mock_sendok,
.send = mock_send,
.special = mock_special,
.ldisc_option_state = mock_ldisc_option_state,
.provide_ldisc = mock_provide_ldisc,
.id = "mock",
};
static Mock *mock_new(void)
{
Mock *mk = snew(Mock);
memset(mk, 0, sizeof(*mk));
mk->conf = conf_new();
do_defaults(NULL, mk->conf);
init_ucs_generic(mk->conf, mk->ucsdata);
mk->ucsdata->line_codepage = CP_437;
mk->context = strbuf_new();
mk->to_terminal = strbuf_new();
mk->to_backend = strbuf_new();
mk->tw.vt = &mock_termwin_vt;
mk->seat.vt = &mock_seat_vt;
mk->backend.vt = &mock_backend_vt;
return mk;
}
static void mock_free(Mock *mk)
{
strbuf_free(mk->context);
strbuf_free(mk->to_terminal);
strbuf_free(mk->to_backend);
conf_free(mk->conf);
term_free(mk->term);
sfree(mk->specials);
sfree(mk);
}
static void reset(Mock *mk)
{
strbuf_clear(mk->context);
strbuf_clear(mk->to_terminal);
strbuf_clear(mk->to_backend);
mk->nspecials = 0;
}
static void test_context(Mock *mk, const char *fmt, ...)
{
strbuf_clear(mk->context);
va_list ap;
va_start(ap, fmt);
put_fmtv(mk->context, fmt, ap);
va_end(ap);
}
static void print_context(Mock *mk, const char *file, int line)
{
printf("%s:%d", file, line);
if (mk->context->len)
printf(" (%s)", mk->context->s);
printf(": ");
}
#define EXPECT(mk, what, ...) \
expect_ ## what(mk, __FILE__, __LINE__, __VA_ARGS__)
static void expect_backend(Mock *mk, const char *file, int line,
ptrlen expected)
{
ptrlen actual = ptrlen_from_strbuf(mk->to_backend);
if (!ptrlen_eq_ptrlen(expected, actual)) {
print_context(mk, file, line);
printf("expected backend output \"");
write_c_string_literal(stdout, expected);
printf("\", got \"");
write_c_string_literal(stdout, actual);
printf("\"\n");
mk->any_test_failed = true;
}
}
static void expect_terminal(Mock *mk, const char *file, int line,
ptrlen expected)
{
ptrlen actual = ptrlen_from_strbuf(mk->to_terminal);
if (!ptrlen_eq_ptrlen(expected, actual)) {
print_context(mk, file, line);
printf("expected terminal output \"");
write_c_string_literal(stdout, expected);
printf("\", got \"");
write_c_string_literal(stdout, actual);
printf("\"\n");
mk->any_test_failed = true;
}
}
static void expect_specials(Mock *mk, const char *file, int line,
size_t nspecials, ...)
{
va_list ap;
static const char *const special_names[] = {
#define SPECIAL(x) #x,
#include "specials.h"
#undef SPECIAL
};
bool match;
if (nspecials != mk->nspecials) {
match = false;
} else {
match = true;
va_start(ap, nspecials);
for (size_t i = 0; i < nspecials; i++) {
SessionSpecialCode code = va_arg(ap, SessionSpecialCode);
int arg = va_arg(ap, int);
if (code != mk->specials[i].code || arg != mk->specials[i].arg)
match = false;
}
va_end(ap);
}
if (!match) {
print_context(mk, file, line);
printf("expected specials [");
va_start(ap, nspecials);
for (size_t i = 0; i < nspecials; i++) {
SessionSpecialCode code = va_arg(ap, SessionSpecialCode);
int arg = va_arg(ap, int);
printf(" %s.%d", special_names[code], arg);
}
va_end(ap);
printf(" ], got [");
for (size_t i = 0; i < mk->nspecials; i++) {
printf(" %s.%d", special_names[mk->specials[i].code],
mk->specials[i].arg);
}
printf(" ]\n");
mk->any_test_failed = true;
}
}
static void test_noedit(Mock *mk)
{
mk->edit = false;
mk->echo = false;
/*
* In non-echo and non-edit mode, the channel is 8-bit clean
*/
for (unsigned c = 0; c < 256; c++) {
char buf[1];
test_context(mk, "c=%02x", c);
buf[0] = c;
ldisc_send(mk->ldisc, buf, 1, false);
EXPECT(mk, backend, make_ptrlen(buf, 1));
reset(mk);
}
/* ... regardless of the 'interactive' flag */
for (unsigned c = 0; c < 256; c++) {
char buf[1];
test_context(mk, "c=%02x", c);
buf[0] = c;
ldisc_send(mk->ldisc, buf, 1, true);
EXPECT(mk, backend, make_ptrlen(buf, 1));
reset(mk);
}
/* ... and any nonzero character does the same thing even if sent
* with the magic -1 length flag */
for (unsigned c = 1; c < 256; c++) {
char buf[2];
test_context(mk, "c=%02x", c);
buf[0] = c;
buf[1] = '\0';
ldisc_send(mk->ldisc, buf, -1, true);
EXPECT(mk, backend, make_ptrlen(buf, 1));
reset(mk);
}
/*
* Test the special-character cases for Telnet.
*/
conf_set_int(mk->conf, CONF_protocol, PROT_TELNET);
conf_set_bool(mk->conf, CONF_telnet_newline, false);
conf_set_bool(mk->conf, CONF_telnet_keyboard, false);
ldisc_configure(mk->ldisc, mk->conf);
/* Without telnet_newline or telnet_keyboard, these all do the
* normal thing */
ldisc_send(mk->ldisc, "\x0D", -1, true);
EXPECT(mk, backend, PTRLEN_LITERAL("\x0D"));
reset(mk);
ldisc_send(mk->ldisc, "\x08", -1, true);
EXPECT(mk, backend, PTRLEN_LITERAL("\x08"));
reset(mk);
ldisc_send(mk->ldisc, "\x7F", -1, true);
EXPECT(mk, backend, PTRLEN_LITERAL("\x7F"));
reset(mk);
ldisc_send(mk->ldisc, "\x03", -1, true);
EXPECT(mk, backend, PTRLEN_LITERAL("\x03"));
reset(mk);
ldisc_send(mk->ldisc, "\x1A", -1, true);
EXPECT(mk, backend, PTRLEN_LITERAL("\x1A"));
reset(mk);
/* telnet_newline controls translation of CR into SS_EOL */
conf_set_bool(mk->conf, CONF_telnet_newline, true);
ldisc_configure(mk->ldisc, mk->conf);
ldisc_send(mk->ldisc, "\x0D", -1, true);
EXPECT(mk, specials, 1, SS_EOL, 0);
reset(mk);
/* And telnet_keyboard controls the others */
conf_set_bool(mk->conf, CONF_telnet_newline, false);
conf_set_bool(mk->conf, CONF_telnet_keyboard, true);
ldisc_configure(mk->ldisc, mk->conf);
ldisc_send(mk->ldisc, "\x08", -1, true);
EXPECT(mk, specials, 1, SS_EC, 0);
reset(mk);
ldisc_send(mk->ldisc, "\x7F", -1, true);
EXPECT(mk, specials, 1, SS_EC, 0);
reset(mk);
ldisc_send(mk->ldisc, "\x03", -1, true);
EXPECT(mk, specials, 1, SS_IP, 0);
reset(mk);
ldisc_send(mk->ldisc, "\x1A", -1, true);
EXPECT(mk, specials, 1, SS_SUSP, 0);
reset(mk);
/*
* In echo-but-no-edit mode, we also expect that every character
* is echoed back to the display as a side effect, including when
* it's sent as a special -1 keystroke.
*
* This state only comes up in Telnet, because that has protocol
* options to independently configure echo and edit. Telnet is
* also the most complicated of the protocols because of the above
* special cases, so we stay in Telnet mode for this test.
*/
mk->echo = true;
for (unsigned c = 0; c < 256; c++) {
char buf[1];
test_context(mk, "c=%02x", c);
buf[0] = c;
ldisc_send(mk->ldisc, buf, 1, false);
EXPECT(mk, terminal, make_ptrlen(buf, 1));
reset(mk);
}
for (unsigned c = 1; c < 256; c++) {
char buf[2];
test_context(mk, "c=%02x", c);
buf[0] = c;
buf[1] = '\0';
ldisc_send(mk->ldisc, buf, -1, true);
EXPECT(mk, terminal, make_ptrlen(buf, 1));
reset(mk);
}
do_defaults(NULL, mk->conf);
ldisc_configure(mk->ldisc, mk->conf);
}
static void test_edit(Mock *mk, bool echo)
{
static const char *const ctls = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_";
mk->edit = true;
mk->echo = echo;
#define EXPECT_TERMINAL(mk, val) do { \
if (!echo) EXPECT(mk, terminal, PTRLEN_LITERAL("")); \
else EXPECT(mk, terminal, val); \
} while (0)
/* ASCII printing characters all print when entered, but don't go
* to the terminal until Return is pressed */
for (unsigned c = 0x20; c < 0x7F; c++) {
char buf[3];
test_context(mk, "c=%02x", c);
buf[0] = c;
ldisc_send(mk->ldisc, buf, 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, make_ptrlen(buf, 1));
ldisc_send(mk->ldisc, "\015", 1, false);
buf[1] = '\015';
buf[2] = '\012';
EXPECT(mk, backend, make_ptrlen(buf, 3));
EXPECT_TERMINAL(mk, make_ptrlen(buf, 3));
reset(mk);
}
/* C0 control characters mostly show up as ^X or similar */
for (unsigned c = 0; c < 0x1F; c++) {
char backbuf[3];
char termbuf[4];
switch (ctls[c]) {
case 'D': continue; /* ^D sends EOF */
case 'M': continue; /* ^M is Return */
case 'R': continue; /* ^R redisplays line */
case 'U': continue; /* ^U deletes the line */
case 'V': continue; /* ^V makes the next char literal */
case 'W': continue; /* ^W deletes a word */
/*
* ^H / ^? are not included here. Those are treated
* literally if sent as plain input bytes. Only sending
* them as special via length==-1 causes them to act as
* backspace, which I think was simply because there _is_
* a dedicated key that can do that function, so there's
* no need to also eat the Ctrl+thing combo.
*/
/*
* Also, ^C, ^Z and ^\ self-insert (when not in Telnet
* mode) but have the side effect of erasing the line
* buffer so far. In this loop, that doesn't show up,
* because the line buffer is empty already. However, I
* don't test that, because it's silly, and probably
* doesn't want to keep happening!
*/
}
test_context(mk, "c=%02x", c);
backbuf[0] = c;
ldisc_send(mk->ldisc, backbuf, 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
termbuf[0] = '^';
termbuf[1] = ctls[c];
EXPECT_TERMINAL(mk, make_ptrlen(termbuf, 2));
ldisc_send(mk->ldisc, "\015", 1, false);
backbuf[1] = '\015';
backbuf[2] = '\012';
EXPECT(mk, backend, make_ptrlen(backbuf, 3));
termbuf[2] = '\015';
termbuf[3] = '\012';
EXPECT_TERMINAL(mk, make_ptrlen(termbuf, 4));
reset(mk);
}
/* Prefixed with ^V, the same is true of _all_ C0 controls */
for (unsigned c = 0; c < 0x1F; c++) {
char backbuf[3];
char termbuf[4];
test_context(mk, "c=%02x", c);
backbuf[0] = 'V' & 0x1F;
ldisc_send(mk->ldisc, backbuf, 1, false);
backbuf[0] = c;
ldisc_send(mk->ldisc, backbuf, 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
termbuf[0] = '^';
termbuf[1] = ctls[c];
EXPECT_TERMINAL(mk, make_ptrlen(termbuf, 2));
ldisc_send(mk->ldisc, "\015", 1, false);
backbuf[1] = '\015';
backbuf[2] = '\012';
EXPECT(mk, backend, make_ptrlen(backbuf, 3));
termbuf[2] = '\015';
termbuf[3] = '\012';
EXPECT_TERMINAL(mk, make_ptrlen(termbuf, 4));
reset(mk);
}
/* Deleting an ASCII character sends a single BSB and deletes just
* that byte from the buffer */
ldisc_send(mk->ldisc, "ab", 2, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("ab"));
ldisc_send(mk->ldisc, "\x08", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("ab\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("a\x0D\x0A"));
reset(mk);
/* Deleting a character written as a ^X code sends two BSBs to
* wipe out the two-character display sequence */
ldisc_send(mk->ldisc, "a\x02", 2, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("a^B"));
ldisc_send(mk->ldisc, "\x7F", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("a^B\x08 \x08\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("a\x0D\x0A"));
reset(mk);
/* ^D sends the line editing buffer without a trailing Return, if
* it's non-empty */
ldisc_send(mk->ldisc, "abc\x04", 4, false);
EXPECT(mk, backend, PTRLEN_LITERAL("abc"));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("abc\x0D\x0A"));
reset(mk);
/* But if the buffer is empty, ^D sends SS_EOF */
ldisc_send(mk->ldisc, "\x04", 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL(""));
EXPECT(mk, specials, 1, SS_EOF, 0);
reset(mk);
/* ^M with the special flag is the Return key, and sends the line */
ldisc_send(mk->ldisc, "abc", 3, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc"));
ldisc_send(mk->ldisc, "\x0D", -1, true);
EXPECT(mk, backend, PTRLEN_LITERAL("abc\x0D\x0A"));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc\x0D\x0A"));
reset(mk);
/* In non-LE_CRLF_NEWLINE mode, either of ^M or ^J without the
* special flag also sends the line */
conf_set_int(mk->conf, CONF_protocol, PROT_SSH);
ldisc_configure(mk->ldisc, mk->conf);
ldisc_send(mk->ldisc, "abc", 3, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc"));
ldisc_send(mk->ldisc, "\x0D", 1, true);
EXPECT(mk, backend, PTRLEN_LITERAL("abc\x0D"));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc\x0D\x0A"));
reset(mk);
ldisc_send(mk->ldisc, "abc", 3, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc"));
ldisc_send(mk->ldisc, "\x0A", 1, true);
EXPECT(mk, backend, PTRLEN_LITERAL("abc\x0D"));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc\x0D\x0A"));
reset(mk);
/* In LE_CRLF_NEWLINE mode, non-special ^J is just literal */
conf_set_int(mk->conf, CONF_protocol, PROT_RAW);
ldisc_configure(mk->ldisc, mk->conf);
ldisc_send(mk->ldisc, "abc", 3, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc"));
ldisc_send(mk->ldisc, "\x0A", 1, true);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc^J"));
/* So when we press Return it's sent */
ldisc_send(mk->ldisc, "\x0D", -1, true);
EXPECT(mk, backend, PTRLEN_LITERAL("abc\x0A\x0D\x0A"));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc^J\x0D\x0A"));
reset(mk);
/* In LE_CRLF_NEWLINE mode, non-special ^M is literal, but if
* followed with ^J, they combine into a Return */
conf_set_int(mk->conf, CONF_protocol, PROT_RAW);
ldisc_configure(mk->ldisc, mk->conf);
ldisc_send(mk->ldisc, "abc", 3, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc"));
ldisc_send(mk->ldisc, "\x0D", 1, true);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc^M"));
/* So when we press Return it's sent */
ldisc_send(mk->ldisc, "\x0A", 1, true);
EXPECT(mk, backend, PTRLEN_LITERAL("abc\x0D\x0A"));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc^M\x08 \x08\x08 \x08\x0D\x0A"));
reset(mk);
/* ^R redraws the current line, after printing "^R" at the end of
* the previous attempt to make it clear that that's what
* happened */
ldisc_send(mk->ldisc, "a\x01", 2, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("a^A"));
ldisc_send(mk->ldisc, "\x12", 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("a^A^R\x0D\x0A" "a^A"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
reset(mk);
/* ^U deletes the whole line */
ldisc_send(mk->ldisc, "a b c", 5, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("a b c"));
ldisc_send(mk->ldisc, "\x15", 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(
mk, PTRLEN_LITERAL(
"a b c\x08 \x08\x08 \x08\x08 \x08\x08 \x08\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("\x0D\x0A"));
EXPECT_TERMINAL(
mk, PTRLEN_LITERAL(
"a b c\x08 \x08\x08 \x08\x08 \x08\x08 \x08\x08 \x08\x0D\x0A"));
reset(mk);
/* And it still knows that a control character written as ^X takes
* two BSBs to delete */
ldisc_send(mk->ldisc, "a\x02" "c", 3, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("a^Bc"));
ldisc_send(mk->ldisc, "\x15", 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(
mk, PTRLEN_LITERAL("a^Bc\x08 \x08\x08 \x08\x08 \x08\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
reset(mk);
/* ^W deletes a word, which means that it deletes to the most
* recent boundary with a space on the left and a nonspace on the
* right. (Or the beginning of the string, whichever comes first.) */
ldisc_send(mk->ldisc, "hello, world\x17", 13, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(
mk, PTRLEN_LITERAL(
"hello, world\x08 \x08\x08 \x08\x08 \x08\x08 \x08\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("hello, \x0D\x0A"));
reset(mk);
ldisc_send(mk->ldisc, "hello, world \x17", 14, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(
mk, PTRLEN_LITERAL(
"hello, world "
"\x08 \x08\x08 \x08\x08 \x08\x08 \x08\x08 \x08\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("hello, \x0D\x0A"));
reset(mk);
ldisc_send(mk->ldisc, " hello \x17", 8, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(
mk, PTRLEN_LITERAL(
" hello \x08 \x08\x08 \x08\x08 \x08\x08 \x08\x08 \x08\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(" \x0D\x0A"));
reset(mk);
ldisc_send(mk->ldisc, "hello \x17", 7, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(
mk, PTRLEN_LITERAL(
"hello \x08 \x08\x08 \x08\x08 \x08\x08 \x08\x08 \x08\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("\x0D\x0A"));
reset(mk);
/* And this too knows that a control character written as ^X takes
* two BSBs to delete */
ldisc_send(mk->ldisc, "a\x02" "c", 3, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("a^Bc"));
ldisc_send(mk->ldisc, "\x17", 1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(
mk, PTRLEN_LITERAL("a^Bc\x08 \x08\x08 \x08\x08 \x08\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
reset(mk);
/* Test handling of ^C and friends in non-telnet_keyboard mode */
ldisc_send(mk->ldisc, "abc\x03", 4, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc\x08 \x08\x08 \x08\x08 \x08^C"));
EXPECT(mk, specials, 1, SS_EL, 0);
ldisc_send(mk->ldisc, "\x0D", -1, false);
reset(mk);
ldisc_send(mk->ldisc, "abc\x1a", 4, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc\x08 \x08\x08 \x08\x08 \x08^Z"));
EXPECT(mk, specials, 1, SS_EL, 0);
ldisc_send(mk->ldisc, "\x0D", -1, false);
reset(mk);
ldisc_send(mk->ldisc, "abc\x1c", 4, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc\x08 \x08\x08 \x08\x08 \x08^\\"));
EXPECT(mk, specials, 1, SS_EL, 0);
ldisc_send(mk->ldisc, "\x0D", -1, false);
reset(mk);
/* And in telnet_keyboard mode */
conf_set_bool(mk->conf, CONF_telnet_keyboard, true);
ldisc_configure(mk->ldisc, mk->conf);
/* FIXME: should we _really_ be sending EL before each of these? */
ldisc_send(mk->ldisc, "abc\x03", 4, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc\x08 \x08\x08 \x08\x08 \x08"));
EXPECT(mk, specials, 2, SS_EL, 0, SS_IP, 0);
ldisc_send(mk->ldisc, "\x0D", -1, false);
reset(mk);
ldisc_send(mk->ldisc, "abc\x1a", 4, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc\x08 \x08\x08 \x08\x08 \x08"));
EXPECT(mk, specials, 2, SS_EL, 0, SS_SUSP, 0);
ldisc_send(mk->ldisc, "\x0D", -1, false);
reset(mk);
ldisc_send(mk->ldisc, "abc\x1c", 4, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("abc\x08 \x08\x08 \x08\x08 \x08"));
EXPECT(mk, specials, 2, SS_EL, 0, SS_ABORT, 0);
ldisc_send(mk->ldisc, "\x0D", -1, false);
reset(mk);
conf_set_bool(mk->conf, CONF_telnet_keyboard, false);
ldisc_configure(mk->ldisc, mk->conf);
/* Test UTF-8 characters of various lengths and ensure deleting
* one deletes the whole character from the buffer (by pressing
* Return and seeing what gets sent) but sends a number of BSBs
* corresponding to the character's terminal width */
mk->term->utf = true;
ldisc_send(mk->ldisc, "\xC2\xA0\xC2\xA1", 4, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xC2\xA0\xC2\xA1"));
ldisc_send(mk->ldisc, "\x08", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xC2\xA0\xC2\xA1\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("\xC2\xA0\x0D\x0A"));
reset(mk);
ldisc_send(mk->ldisc, "\xE2\xA0\x80\xE2\xA0\x81", 6, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xE2\xA0\x80\xE2\xA0\x81"));
ldisc_send(mk->ldisc, "\x08", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xE2\xA0\x80\xE2\xA0\x81\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("\xE2\xA0\x80\x0D\x0A"));
reset(mk);
ldisc_send(mk->ldisc, "\xF0\x90\x80\x80\xF0\x90\x80\x81", 8, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xF0\x90\x80\x80\xF0\x90\x80\x81"));
ldisc_send(mk->ldisc, "\x08", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xF0\x90\x80\x80\xF0\x90\x80\x81"
"\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("\xF0\x90\x80\x80\x0D\x0A"));
reset(mk);
/* Double-width characters (Hangul, as it happens) */
ldisc_send(mk->ldisc, "\xEA\xB0\x80\xEA\xB0\x81", 6, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xEA\xB0\x80\xEA\xB0\x81"));
ldisc_send(mk->ldisc, "\x08", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xEA\xB0\x80\xEA\xB0\x81"
"\x08 \x08\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("\xEA\xB0\x80\x0D\x0A"));
reset(mk);
/* Zero-width characters */
ldisc_send(mk->ldisc, "\xE2\x80\x8B\xE2\x80\x8B", 6, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xE2\x80\x8B\xE2\x80\x8B"));
ldisc_send(mk->ldisc, "\x08", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xE2\x80\x8B\xE2\x80\x8B"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("\xE2\x80\x8B\x0D\x0A"));
reset(mk);
/* And reset back to non-UTF-8 mode and expect high-bit-set bytes
* to be treated individually, as characters in a single-byte
* charset. (In our case, given the test config, that will be
* CP437, but it makes no difference to the editing behaviour.) */
mk->term->utf = false;
ldisc_send(mk->ldisc, "\xC2\xA0\xC2\xA1", 4, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xC2\xA0\xC2\xA1"));
ldisc_send(mk->ldisc, "\x08", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL(""));
EXPECT_TERMINAL(mk, PTRLEN_LITERAL("\xC2\xA0\xC2\xA1\x08 \x08"));
ldisc_send(mk->ldisc, "\x0D", -1, false);
EXPECT(mk, backend, PTRLEN_LITERAL("\xC2\xA0\xC2\x0D\x0A"));
reset(mk);
/* Make sure we flush all the terminal contents at the end of this
* function */
ldisc_send(mk->ldisc, "\x0D", 1, false);
reset(mk);
#undef EXPECT_TERMINAL
}
const struct BackendVtable *const backends[] = { &mock_backend_vt, NULL };
int main(void)
{
Mock *mk = mock_new();
mk->term = term_init(mk->conf, mk->ucsdata, &mk->tw);
Ldisc *ldisc = ldisc_create(mk->conf, mk->term, &mk->backend, &mk->seat);
term_size(mk->term, 80, 24, 0);
test_noedit(mk);
test_edit(mk, true);
test_edit(mk, false);
ldisc_free(ldisc);
bool failed = mk->any_test_failed;
mock_free(mk);
if (failed) {
printf("Test suite FAILED!\n");
return 1;
} else {
printf("Test suite passed\n");
return 0;
}
}
Reference in New Issue View Git Blame Copy Permalink