Vhex-Kernel-Core
/
vxKernel
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

vxGOS - v0.7.0-9 : fix console issues 

*add*
> [scripts]
  | [vxdev] add log level selection
> [bootloader]
  | [unitests] input buffer checks

*update*
> [bootloader]
  | [console] isolate line discipline
  | [console] isolate cursor interaction
  | [console] isolate buffer closing ("\n\0" insertion)
  | [console] isolate input buffer initialisation and closing
  | [console] rework complete input buffer drawing logic
  | [console] proper save font information
  | [display] allow dascii font NULL argument (auto fetch font information)
  | [unitests] output buffer checks

*fix*
> [scripts]
  | [vxdev] fix GCDA/GCDO file purge
  | [vxdev] fix coverage color
  | [vxdev] fix coverage error decoding
  | [vxdev] fix requirements.txt parsing error (abort all)
> [bootloader]
  | [console] fix various input buffer error
This commit is contained in:
Yann MAGNIN 2023-05-14 20:44:11 +02:00
parent 18c917f257
commit 584e95e11b
17 changed files with 509 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
scripts/vxdev/__main__.py
View File

@ -33,10 +33,19 @@ def _main(argv):
if not argv:
log.user(__HELP__)
sys.exit(84)
if argv[0] in ['-v', '-vv', '-vvv']:
log.level += len(argv[0]) - 1
argv = argv[1:]
if not argv:
log.error(__HELP__)
sys.exit(84)
if argv[0] == 'build':
sys.exit(cli.build(argv[1:]))
if argv[0] == 'unitests':
sys.exit(cli.unitests(argv[1:]))
print(f"unrecognized argument '{argv[0]}'", file=sys.stderr)
sys.exit(84)

2
scripts/vxdev/core/unitests/criterion.py
View File

@ -19,7 +19,7 @@ def criterion_unitests_run(bininfo):
""" run criterion unitests (purge converage informaiton)
"""
log.debug(f"{bininfo[0]}: purge GCDA file...")
query = f"{os.path.dirname(bininfo[1])}/**/*.gcda"
query = f"{os.path.dirname(bininfo[1])}/**/*.gcd[ao]"
for gcda in glob.glob(query, recursive=True):
log.debug(f"- {gcda}...")
os.remove(gcda)

5
scripts/vxdev/core/unitests/gcovr.py
View File

@ -42,8 +42,8 @@ def _gcovr_display_output(lineinfo):
for line in lineinfo:
maxwidth = max(len(line[0]), maxwidth)
for line in lineinfo:
if (percent := int(line[3][:-1])) <= 25:
color = '\033[31m'
percent = int(line[3][:-1])
color = '\033[31m'
if 50 <= percent <= 90:
color = '\033[33m'
if percent >= 90:
@ -66,6 +66,7 @@ def gcovr_unitests_run(bininfo):
proc = subprocess.run(cmd.split(), capture_output=True, check=False)
if proc.returncode != 0:
log.error(f"{bininfo[0]}: code coverage error, skipped")
log.error(proc.stderr.decode('utf8'))
return -1
lineinfo = _gcovr_parse_output(proc.stdout, bininfo[2]['covered'])
_gcovr_display_output(lineinfo)

6
scripts/vxdev/core/unitests/requirements.py
View File

@ -27,8 +27,7 @@ def requirements_unitests_parse(prefix, suite, test):
testname = f"{suite}:{test}"
pathname = f"{prefix}/unitests/{test}/requirements.txt"
if not os.path.exists(prefix):
log.error(f"{pathname}: file doesn't exists, skipped")
return None
log.emergency(f"{pathname}: file doesn't exists, skipped")
line_id = 0
requirement = {
@ -59,11 +58,10 @@ def requirements_unitests_parse(prefix, suite, test):
continue
real_filename = f"{prefix}/{line[1]}"
if not os.path.exists(real_filename):
log.error(
log.emergency(
f"{testname}: dependency '{real_filename}'"
"not exists"
)
return None
mapping[line[0][1]].append(real_filename)
log.debug(f"- requirements.txt : {requirement}")

12
vxgos/bootloader/boards/fxcg50/src/console/handle.c
View File

@ -20,7 +20,7 @@ int console_key_handle_special(struct console *console, int key)
console->input.mode.maj ^= 1;
return 1;
case KEY_OPTN:
console->input.mode.ctrl ^= 1;
console->input.mode.ctrl ^= 1;
return 1;
case KEY_DOT:
console_buffer_in_insert(console, ' ');
@ -29,19 +29,13 @@ int console_key_handle_special(struct console *console, int key)
console_buffer_in_remove(console);
return 1;
case KEY_EXE:
/* Add End Of Line character */
console->input.buffer.data[console->input.buffer.size - 1] = '\n';
console->input.buffer.data[console->input.buffer.size] = '\0';
/* indicate that the EXE key has been pressed. */
console->input.mode.exit = 1;
return 1;
case KEY_LEFT:
if (console->input.buffer.cursor > 0)
console->input.buffer.cursor -= 1;
console_buffer_in_cursor_move(console, -1);
return 1;
case KEY_RIGHT:
if (console->input.buffer.cursor < console->input.buffer.size - 1)
console->input.buffer.cursor += 1;
console_buffer_in_cursor_move(console, 1);
return 1;
default:
return 0;

31
vxgos/bootloader/include/bootloader/console.h
View File

@ -6,6 +6,8 @@
#include <sys/types.h>
#include <stdarg.h>
#include "bootloader/display.h"
//---
// macros
//---
@ -42,6 +44,7 @@ struct console
uint8_t *data;
unsigned int cursor;
size_t size;
size_t size_frame;
} buffer;
} output;
@ -79,6 +82,7 @@ struct console
int fg;
int bg;
} color;
struct font *font;
} _private;
};
@ -101,6 +105,7 @@ extern int console_vwrite(struct console *console, const char *f, va_list ap);
/* console_close() : close console */
extern int console_close(struct console *console);
//---
// Low-level API
//---
@ -114,6 +119,20 @@ extern int console_buffer_out_insert(struct console *c, char *b, size_t nb);
/* console_buffer_out_display() : display the output buffer on screen */
extern int console_buffer_out_display(struct console *console);
/* console_buffer_in_init() : initialize the input buffer */
extern int console_buffer_in_init(struct console *console, void *b, size_t n);
/* console_buffer_in_uninit() : uninit input buffer and quit */
extern int console_buffer_in_uninit(struct console *console);
/* console_buffer_in_reset() : reset the input buffer */
extern void console_buffer_in_reset(struct console *console);
/* console_buffer_in_cursor_move() : move cursor in on direction */
extern void console_buffer_in_cursor_move(struct console *console, int dir);
/* console_buffer_in_display() : display input buffer */
extern void console_buffer_in_display(struct console *console);
@ -123,6 +142,18 @@ extern void console_buffer_in_remove(struct console *console);
/* console_buffer_in_insert() - Insert character based on cursor position */
extern int console_buffer_in_insert(struct console *console, char n);
/* console_line_discipline() - Check "special" char */
extern int console_line_discipline(
struct console *console,
char n,
unsigned int *x,
unsigned int *y
);
/* console_key_get() : get current pressed key */
extern int console_key_get(void);

156
vxgos/bootloader/src/console/buffer/input.c
View File

@ -7,29 +7,123 @@
// Public
//---
/* console_buffer_in_display() : display input buffer */
void console_buffer_in_display(struct console *console)
/* console_buffer_in_init() : initialize the input buffer */
int console_buffer_in_init(struct console *console, void *buffer, size_t nb)
{
/* mark special char flags to inform cursor position */
console->input.buffer.data[console->input.buffer.cursor] |= 0x80;
if (console == NULL)
return -1;
if (buffer == NULL)
return -2;
if (nb < 2)
return -3;
console->input.cursor.saved = console->output.buffer.cursor;
console->input.cursor.x = console->output.cursor.x;
console->input.cursor.y = console->output.cursor.y;
console->input.buffer.data = buffer;
console->input.buffer.size = 0;
console->input.buffer.max = nb;
console->input.buffer.cursor = 0;
console->input.mode_raw = 0x00;
return 0;
}
/* restore terminal context */
console->output.cursor.x = console->input.cursor.x;
console->output.cursor.y = console->input.cursor.y;
console->output.buffer.cursor = console->input.cursor.saved;
/* console_buffer_in_uninit() : uninit input buffer and quit */
int console_buffer_in_uninit(struct console *console)
{
int readed;
/* check error */
if (console == NULL)
return -1;
/* inject the new-line and the EOL */
console->input.buffer.data[console->input.buffer.size] = '\n';
console->input.buffer.size += 1;
console->input.buffer.data[console->input.buffer.size] = '\0';
/* insert the input buffer */
console_buffer_out_insert(
console,
console->input.buffer.data,
console->input.buffer.size
);
/* reset buffer information and quit */
readed = console->input.buffer.size;
console->input.buffer.data = NULL;
console->input.buffer.size = 0;
console->input.buffer.max = 0;
return readed;
}
/* console_buffer_in_reset() : reset the input buffer */
void console_buffer_in_reset(struct console *console)
{
console->input.buffer.cursor = 0;
console->input.buffer.size = 0;
}
/* console_buffer_in_cursor_move() : move cursor in on direction */
void console_buffer_in_cursor_move(struct console *console, int direction)
{
if (direction < 0) {
if (console->input.buffer.cursor > 0)
console->input.buffer.cursor -= 1;
} else {
if (console->input.buffer.cursor < console->input.buffer.size)
console->input.buffer.cursor += 1;
}
}
/* console_buffer_in_display() : display input buffer */
void console_buffer_in_display(struct console *console)
{
unsigned int x;
unsigned int y;
/* precalculate the cursor drawing position */
x = console->input.cursor.x + 1;
y = console->input.cursor.y;
for (size_t i = 0 ; i < console->input.buffer.cursor ; ++i)
{
console_line_discipline(
console,
console->input.buffer.data[i],
&x,
&y
);
}
x *= console->winsize.ft_xpixel;
y *= console->winsize.ft_ypixel;
/* display management */
dclear(console->_private.color.bg);
console_buffer_out_display(console);
for (size_t i = 0; i < console->input.buffer.size ; ++i)
{
if (
console_line_discipline(
console,
console->input.buffer.data[i],
&console->output.cursor.x,
&console->output.cursor.y
) == 0
) {
dascii(
console->output.cursor.x * console->winsize.ft_xpixel,
console->output.cursor.y * console->winsize.ft_ypixel,
console->_private.color.fg,
console->input.buffer.data[i],
console->_private.font
);
}
}
dline(
x, y,
x, y + console->winsize.ft_ypixel,
console->_private.color.fg
);
dupdate();
/* remove cursor mark */
console->input.buffer.data[console->input.buffer.cursor] &= ~0x80;
}
/* console_buffer_in_remove(): Remove character based on cursor position */
@ -38,17 +132,23 @@ void console_buffer_in_remove(struct console *console)
/* check if this action is possible */
if (console->input.buffer.cursor == 0)
return;
/* move data if needed */
if (console->input.buffer.cursor < console->input.buffer.size - 1) {
memcpy(
&console->input.buffer.data[console->input.buffer.cursor - 1],
&console->input.buffer.data[console->input.buffer.cursor],
console->input.buffer.size - console->input.buffer.cursor
);
if (console->input.buffer.cursor < console->input.buffer.size)
{
for (
size_t i = console->input.buffer.cursor - 1;
i < console->input.buffer.size - 1;
i++
) {
console->input.buffer.data[i] = console->input.buffer.data[i + 1];
}
}
/* force NULL-char and update cursor/size */
console->input.buffer.cursor = console->input.buffer.cursor - 1;
console->input.buffer.data[--console->input.buffer.size - 1] = '\0';
console->input.buffer.size -= 1;
console->input.buffer.cursor -= 1;
console->input.buffer.data[console->input.buffer.size] = '\0';
}
/* console_buffer_in_insert() - Insert character based on cursor position */
@ -57,17 +157,23 @@ int console_buffer_in_insert(struct console *console, char n)
unsigned int i;
/* save space for the "\n\0" (EOL) */
if (console->input.buffer.size + 1 >= console->input.buffer.max)
if (console->input.buffer.size + 2 >= console->input.buffer.max)
return -1;
/* move data if needed */
if (console->input.buffer.cursor < console->input.buffer.size - 1) {
if (console->input.buffer.cursor < console->input.buffer.size) {
i = console->input.buffer.size + 1;
while (--i >= console->input.buffer.cursor) {
while (--i > console->input.buffer.cursor) {
console->input.buffer.data[i] = console->input.buffer.data[i - 1];
}
}
/* insert the character and force NULL-char */
console->input.buffer.data[console->input.buffer.cursor++] = n;
console->input.buffer.data[++console->input.buffer.size] = '\0';
/* insert the character and force-update all */
console->input.buffer.data[console->input.buffer.cursor] = n;
console->input.buffer.cursor += 1;
console->input.buffer.size += 1;
/* force NULL char */
console->input.buffer.data[console->input.buffer.size] = '\0';
return 0;
}

71
vxgos/bootloader/src/console/buffer/line_discipline.c Normal file
View File

@ -0,0 +1,71 @@
#include "bootloader/console.h"
//---
// Internals
//---
/* console_vertical_update() - Update vertical cursor */
static void console_vertical_update(struct console *console, unsigned int *y)
{
if (*y + 1 < console->winsize.ws_col) {
*y += 1;
}
}
/* console_horizontal_update() - Update horizotal cursor */
static int console_horizontal_update(
struct console *console,
unsigned int *x,
unsigned int *y
) {
*x += 1;
if (*x >= console->winsize.ws_col)
{
console_vertical_update(console, y);
*x = 0;
return 1;
}
return 0;
}
//---
// Public
//---
/* console_line_discipline() - Check "special" char */
int console_line_discipline(
struct console *console,
char n,
unsigned int *x,
unsigned int *y
) {
int offset;
switch (n)
{
case '\n':
*x = 0;
console_vertical_update(console, y);
return 1;
case '\b':
if (*x > 0)
*x -= 1;
return 1;
case '\v':
console_vertical_update(console, y);
return 1;
case '\r':
console->output.cursor.x = 0;
return 1;
case '\t':
offset = *x;
offset -= ((*x / 5) * 5);
offset = 5 - offset;
while (--offset >= 0)
console_horizontal_update(console, x, y);
return 1;
default:
console_horizontal_update(console, x, y);
return 0;
}
}

125
vxgos/bootloader/src/console/buffer/output.c
View File

@ -4,66 +4,6 @@
#include "bootloader/console.h"
#include "bootloader/display.h"
//---
// Internals
//---
/* console_vertical_update() - Update vertical cursor */
static void console_vertical_update(struct console *console)
{
if (console->output.cursor.y + 1 < console->winsize.ws_col) {
console->output.cursor.y = console->output.cursor.y + 1;
return;
}
}
/* console_horizontal_update() - Update horizotal cursor */
static int console_horizontal_update(struct console *console)
{
console->output.cursor.x = console->output.cursor.x + 1;
if (console->output.cursor.x >= console->winsize.ws_col)
{
console_vertical_update(console);
console->output.cursor.x = 0;
return 1;
}
return 0;
}
/* console_line_discipline() - Check "special" char */
static int console_line_discipline(struct console *console, char n)
{
int offset;
switch (n)
{
case '\n':
console->output.cursor.x = 0;
console_vertical_update(console);
return 1;
case '\b':
if (console->output.cursor.x > 0)
console->output.cursor.x = console->output.cursor.x - 1;
return 1;
case '\v':
console_vertical_update(console);
return 1;
case '\r':
console->output.cursor.x = 0;
return 1;
case '\t':
/* Check if we need a new line or not. */
offset = console->output.cursor.x;
offset -= ((console->output.cursor.x / 5) * 5);
offset = 5 - offset;
while (--offset >= 0)
console_horizontal_update(console);
return 1;
default:
return 0;
}
}
//---
// Public
//---
@ -124,11 +64,7 @@ int console_buffer_out_insert(struct console *console, char *buffer, size_t nb)
int console_buffer_out_display(struct console *console)
{
uint8_t *buffer;
char tmp[2];
int counter;
int cursor;
int x;
int y;
size_t counter;
int i;
/* check obvious error */
@ -140,34 +76,38 @@ int console_buffer_out_display(struct console *console)
console->output.cursor.x = 0;
console->output.cursor.y = 0;
i = console->output.buffer.cursor;
//if (i < 0)
// i = console->output.buffer.size - 1;
buffer = &console->output.buffer.data[0];
counter = 0;
while (1)
{
/* decrease the cursor and avoid circular effect */
/* decrease the cursor and handle circular effect */
if (--i < 0)
i = console->output.buffer.size - 1;
/* check loop condition */
if (i == (int)console->output.buffer.cursor)
break;
if (buffer[i] == '\0')
break;
/* update internal counter and check display limit */
counter += 1;
if (counter >= console->output.buffer.size_frame)
break;
/* handle the character (only to force update cursors) */
if (console_line_discipline(console, buffer[i] & 0x7f) == 0)
console_horizontal_update(console);
console_line_discipline(
console,
buffer[i],
&console->output.cursor.x,
&console->output.cursor.y
);
if (console->output.cursor.y >= console->winsize.ws_row)
break;
}
/* Display character per character because we need to check special
behaviour (like cariege return, line feed, ...) */
tmp[1] = '\0';
console->output.cursor.x = 0;
console->output.cursor.y = 0;
counter = 0;
while (1)
{
/* update the index */
@ -176,30 +116,21 @@ int console_buffer_out_display(struct console *console)
if (i == (int)console->output.buffer.cursor)
break;
/* update printed char */
counter += 1;
/* get the cursor and remove the potential cursor marker */
cursor = ((buffer[i] & 0x80) != 0);
buffer[i] &= 0x7f;
/* display part (character + cursor if needed) */
x = console->output.cursor.x * console->winsize.ft_xpixel;
y = console->output.cursor.y * console->winsize.ft_ypixel;
if (console_line_discipline(console, buffer[i]) == 0)
{
tmp[0] = buffer[i];
dtext(x, y, console->_private.color.fg, tmp);
console_horizontal_update(console);
}
if (cursor != 0)
{
dline(
x,
y,
x,
y + console->winsize.ft_ypixel,
console->_private.color.fg
if (
console_line_discipline(
console,
buffer[i],
&console->output.cursor.x,
&console->output.cursor.y
) == 0
) {
dascii(
console->output.cursor.x * console->winsize.ft_xpixel,
console->output.cursor.y * console->winsize.ft_ypixel,
console->_private.color.fg,
buffer[i],
console->_private.font
);
}
}

7
vxgos/bootloader/src/console/open.c
View File

@ -32,8 +32,10 @@ int console_open(struct console *console)
console->winsize.ws_row = console->winsize.ws_ypixel;
console->winsize.ws_row /= console->winsize.ft_ypixel;
console->output.buffer.size = console->winsize.ws_row;
console->output.buffer.size *= console->winsize.ws_col;
console->output.buffer.size_frame = console->winsize.ws_row;
console->output.buffer.size_frame *= console->winsize.ws_col;
console->output.buffer.size = console->output.buffer.size_frame;
console->output.buffer.size *= TERM_BUFFER_NB_FRAME;
console->output.buffer.size *= sizeof(uint8_t);
@ -48,5 +50,6 @@ int console_open(struct console *console)
console->_private.color.bg = C_BLACK;
console->_private.color.fg = C_WHITE;
console->_private.font = font;
return 0;
}

19
vxgos/bootloader/src/console/read.c
View File

@ -9,20 +9,15 @@
/* console_read() : console read primitive */
int console_read(struct console *console, void *buffer, size_t nb)
{
int error;
int key;
/* check obvious error */
if (buffer == NULL || nb == 0)
return 0;
error = console_buffer_in_init(console, buffer, nb);
if (error < 0)
return error;
/* initialize internal data */
console->input.cursor.saved = console->output.buffer.cursor;
console->input.cursor.x = console->output.cursor.x;
console->input.cursor.y = console->output.cursor.y;
console->input.buffer.data = buffer;
console->input.buffer.size = 1;
console->input.buffer.max = nb;
console->input.mode_raw = 0x00;
/* force display the empty buffer to draw the cursor line */
console_buffer_in_display(console);
/* keyboard handling
* @note
@ -35,5 +30,5 @@ int console_read(struct console *console, void *buffer, size_t nb)
console_buffer_in_display(console);
}
return console->input.buffer.size;
return console_buffer_in_uninit(console);
}

3
vxgos/bootloader/src/display/dascii.c
View File

@ -18,6 +18,9 @@ void dascii(int x, int y, int color, char n, struct font *font)
if (n <= ' ')
return;
if (font == NULL && dfont_get(&font) != 0)
return;
/* pre-calculate bitmap position information
* @note
* - font data SHOULD be 32-aligned

10
vxgos/bootloader/unitests/console/provided/bios_dupdate.c Normal file
View File

@ -0,0 +1,10 @@
//---
// Public
//---
/* _bios_dupdate() : fake driver */
void _bios_dupdate(void)
{
;
}

4
vxgos/bootloader/unitests/console/requirements.txt
View File

@ -2,9 +2,13 @@
[c] src/console/open.c
[c] src/console/close.c
[c] src/console/buffer/output.c
[c] src/console/buffer/input.c
[c] src/console/buffer/line_discipline.c
# dependencies
[d] src/display/dtext.c
[d] src/display/dline.c
[d] src/display/dascii.c
[d] src/display/dpixel.c
[d] src/display/dclear.c
[d] src/display/dupdate.c

173
vxgos/bootloader/unitests/console/tests/buffer_input.c Normal file
View File

@ -0,0 +1,173 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <criterion/criterion.h>
#include "bootloader/console.h"
#include "utils.h"
//---
// Public
//---
/* buffer_in_insert() : check buffer input insert */
Test(console, buffer_in_insert)
{
extern bool enable_font;
extern bool enable_font_error;
struct console console;
char smallbuffer[5];
/* init console */
enable_font = true;
enable_font_error = false;
console_open(&console);
/* check obvious error */
_creq(console_buffer_in_init(NULL, smallbuffer, 5), -1, "no console");
_creq(console_buffer_in_init(&console, NULL, 5), -2, "no buffer");
_creq(console_buffer_in_init(&console, smallbuffer, 0), -3, "no size");
_creq(console_buffer_in_uninit(NULL), -1, "no console");
/* simple small injection */
_creq(console_buffer_in_init(&console, smallbuffer, 5), 0, "buffer init");
_creq(console_buffer_in_insert(&console, 'a'), 0, "small insert 0");
_creq(console_buffer_in_insert(&console, 'b'), 0, "small insert 1");
_creq(console_buffer_in_insert(&console, 'c'), 0, "small insert 2");
_creq(console_buffer_in_insert(&console, 'd'), -1, "small insert 3");
_creq(console_buffer_in_insert(&console, 'e'), -1, "small insert 4");
_creq(console_buffer_in_insert(&console, 'f'), -1, "small insert 5");
_creq(console_buffer_in_insert(&console, 'g'), -1, "small insert 6");
_creq(console_buffer_in_insert(&console, 'h'), -1, "small insert 7");
_creq(memcmp(console.input.buffer.data, "abc", 3), 0, "small insert");
console_buffer_in_display(&console);
_creq(console_buffer_in_uninit(&console), 4, "uninit error");
/* small injection with moved cursor */
_creq(console_buffer_in_init(&console, smallbuffer, 5), 0, "buffer init");
console_buffer_in_reset(&console);
_creq(console_buffer_in_insert(&console, 'a'), 0, "small insert at 0");
console.input.buffer.cursor = 0;
_creq(console_buffer_in_insert(&console, 'b'), 0, "small insert at 1");
console.input.buffer.cursor = 1;
_creq(console_buffer_in_insert(&console, 'c'), 0, "small insert at 2");
console.input.buffer.cursor = 0;
_creq(console_buffer_in_insert(&console, 'd'), -1, "small insert at 3");
_creq(
memcmp(console.input.buffer.data, "bca", 3), 0,
"('%s' vs '%s')small insert",
console.input.buffer.data,
"bca"
);
console_buffer_in_display(&console);
/* uninit check */
_creq(console_buffer_in_uninit(&console), 4, "uninit error");
/* exit */
console_close(&console);
}
/* buffer_in_remove() : check buffer input remove */
Test(console, buffer_in_remove)
{
extern bool enable_font;
extern bool enable_font_error;
struct console console;
char smallbuffer[11];
/* init console */
enable_font = true;
enable_font_error = false;
console_open(&console);
/* populate the input buffer */
_creq(console_buffer_in_init(&console, smallbuffer, 11), 0, "buffer init");
_creq(console_buffer_in_insert(&console, 'a'), 0, "small insert 0");
_creq(console_buffer_in_insert(&console, 'b'), 0, "small insert 1");
_creq(console_buffer_in_insert(&console, 'c'), 0, "small insert 2");
_creq(console_buffer_in_insert(&console, 'd'), 0, "small insert 3");
_creq(console_buffer_in_insert(&console, 'e'), 0, "small insert 4");
_creq(console_buffer_in_insert(&console, 'f'), 0, "small insert 5");
_creq(console_buffer_in_insert(&console, 'g'), 0, "small insert 6");
_creq(console_buffer_in_insert(&console, 'h'), 0, "small insert 7");
_creq(console_buffer_in_insert(&console, 'i'), 0, "small insert 8");
/* try to remove all char */
_creq(memcmp(console.input.buffer.data, "abcdefghi", 10), 0, "small rm0");
console_buffer_in_cursor_move(&console, -1);
console_buffer_in_cursor_move(&console, -1);
console_buffer_in_cursor_move(&console, -1);
console_buffer_in_remove(&console);
_creq(
memcmp(console.input.buffer.data, "abcdeghi", 9), 0,
"small rm1 (%s vs %s)",
console.input.buffer.data,
"abcdeghi"
);
console_buffer_in_remove(&console);
_creq(memcmp(console.input.buffer.data, "abcdghi", 8), 0, "small rm2");
console_buffer_in_remove(&console);
_creq(memcmp(console.input.buffer.data, "abcghi", 7), 0, "small rm3");
console_buffer_in_remove(&console);
console_buffer_in_remove(&console);
console_buffer_in_remove(&console);
console_buffer_in_remove(&console);
console_buffer_in_remove(&console);
console_buffer_in_remove(&console);
console_buffer_in_remove(&console);
console_buffer_in_remove(&console);
console_buffer_in_remove(&console);
console_buffer_in_remove(&console);
console_buffer_in_remove(&console);
console_buffer_in_remove(&console);
_creq(
memcmp(console.input.buffer.data, "ghi", 4), 0,
"small rm1 (%s vs %s)",
console.input.buffer.data,
"ghi"
);
/* re-populate input buffer */
_creq(console_buffer_in_init(&console, smallbuffer, 5), 0, "buffer init");
_creq(console_buffer_in_insert(&console, 'a'), 0, "small insert 0");
_creq(console_buffer_in_insert(&console, 'b'), 0, "small insert 1");
_creq(console_buffer_in_insert(&console, 'c'), 0, "small insert 2");
/* code coverage cursor move */
_creq(console.input.buffer.cursor, 3, "cursor check 0");
console_buffer_in_cursor_move(&console, -1);
_creq(console.input.buffer.cursor, 2, "cursor check 1");
console_buffer_in_cursor_move(&console, -1);
_creq(console.input.buffer.cursor, 1, "cursor check 2");
console_buffer_in_cursor_move(&console, -1);
_creq(console.input.buffer.cursor, 0, "cursor check 3");
console_buffer_in_cursor_move(&console, -1);
_creq(console.input.buffer.cursor, 0, "cursor check 4");
console_buffer_in_cursor_move(&console, 1);
_creq(console.input.buffer.cursor, 1, "cursor check 4");
console_buffer_in_cursor_move(&console, 1);
_creq(console.input.buffer.cursor, 2, "cursor check 4");
console_buffer_in_cursor_move(&console, 1);
_creq(console.input.buffer.cursor, 3, "cursor check 4");
console_buffer_in_cursor_move(&console, 1);
_creq(console.input.buffer.cursor, 3, "cursor check 4");
/* try to remove with cursor position modification */
_creq(memcmp(console.input.buffer.data, "abc", 4), 0, "small remove 0");
console.input.buffer.cursor = 1;
console_buffer_in_remove(&console);
_creq(memcmp(console.input.buffer.data, "bc", 3), 0, "small remove 1");
console.input.buffer.cursor = 0;
console_buffer_in_remove(&console);
console.input.buffer.cursor = 1;
console_buffer_in_remove(&console);
_creq(memcmp(console.input.buffer.data, "c", 2), 0, "small remove 2");
console.input.buffer.cursor = 1;
console_buffer_in_remove(&console);
_creq(memcmp(console.input.buffer.data, "\0", 1), 0, "small remove 3");
/* uninit check */
_creq(console_buffer_in_uninit(&console), 1, "uninit error");
console_close(&console);
}

28
vxgos/bootloader/unitests/console/tests/buffer.c → vxgos/bootloader/unitests/console/tests/buffer_output.c
View File

@ -130,24 +130,42 @@ Test(console, buffer_out_coverage)
/* cursor handling + multiple insertion */
size = console.output.buffer.size / 2;
buffer = malloc(size);
memset(buffer, 'a' | 0x80, size);
memset(buffer, 'a', size);
console_buffer_out_reset(&console);
console_buffer_out_insert(&console, buffer, size);
_creq(console_buffer_out_display(&console), 747, "cursor check");
console_buffer_out_insert(&console, buffer, size);
_creq(
console_buffer_out_display(&console),
747,
console.output.buffer.size_frame,
"cursor frame size check"
);
console_buffer_out_insert(&console, buffer, size);
_creq(
console_buffer_out_display(&console),
console.output.buffer.size_frame,
"multiple cursor check"
);
/* check vertical break with vertical tab */
memset(buffer, '\v', size);
console_buffer_out_reset(&console);
console_buffer_out_insert(&console, buffer, size);
_creq(
console_buffer_out_display(&console),
console.winsize.ws_row,
"vertical tab limit"
);
/* long buffer insertion */
size *= 4;
buffer = realloc(buffer, size);
memset(buffer, 'a', size);
console_buffer_out_reset(&console);
console_buffer_out_insert(&console, buffer, size);
_creq(console_buffer_out_display(&console), 747, "long buffer check");
_creq(
console_buffer_out_display(&console),
console.output.buffer.size_frame,
"long buffer check"
);
console_close(&console);
free(buffer);

7
vxgos/bootloader/unitests/console/tests/utils.h
View File

@ -2,10 +2,13 @@
#define UNITESTS_UTILS_H
/* _creq() : cr_assert_eq wrapper */
#define _creq(callable, val, msg) \
#define _creq(callable, val, msg, ...) \
do { \
__auto_type _a = callable; \
cr_expect_eq(_a, val, "(%d != %d) "msg, _a, val); \
cr_expect_eq( \
_a, val, "(%d != %d) "msg, _a, val \
__VA_OPT__(,) __VA_ARGS__ \
); \
} while (0)
#endif /* UNITESTS_UTILS_H */