Test results for the library AAlib-1.0 on x86

Summary

Total tests	32
Passed / Failed tests	32 / 0
Warnings	26
Verdict	Test Passed

Warnings (26)

[+] Unexpected Output (26 warnings)

aalib.h, libaa.so
[+] aa_autoinit ( struct aa_hardware_params* params ):aa_context*

Width?[80]Height?[32]

#include <aalib.h>

int main(int argc, char *argv[])

{

struct aa_hardware_params params = aa_defparams;

aa_autoinit(&params); //target call

return 0;

}

[+] aa_autoinitkbd ( struct aa_context* context, int mode ):int

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* context = aa_init(&driver, &defparams, driverdata);

aa_autoinitkbd(context, 0); //target call

return 0;

}

[+] aa_autoinitmouse ( struct aa_context* c, int mode ):int

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_autoinitmouse(c, 0); //target call

return 0;

}

[+] aa_close ( aa_context* c ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_close(c); //target call

return 0;

}

[+] aa_createedit ( aa_context* c, int x, int y, int size, char* s, int maxsize ):struct aa_edit*

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

char s [] = {

'A',

'B',

'C',

'D',

'\0'};

aa_createedit(

16,

4); //target call

return 0;

}

[+] aa_editkey ( struct aa_edit* e, int c ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

char s [] = {

'A',

'B',

'C',

'D',

'\0'};

struct aa_edit* e = aa_createedit(

16,

4);

aa_editkey(e, 4); //target call

return 0;

}

[+] aa_fastrender ( aa_context* c, int x1, int y1, int x2, int y2 ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_fastrender(

16,

24,

32); //target call

return 0;

}

[+] aa_flush ( aa_context* c ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_flush(c); //target call

return 0;

}

[+] aa_getevent ( aa_context* c, int wait ):int

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_getevent(c, 1); //target call

return 0;

}

[+] aa_getkey ( aa_context* c, int wait ):int

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_getkey(c, 1); //target call

return 0;

}

[+] aa_getmouse ( aa_context* c, int* x, int* y, int* b ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

int x = 0;

int y = 0;

int* b = (int*) malloc(sizeof(int)*256);

aa_getmouse(

&x,

&y,

b); //target call

return 0;

}

[+] aa_gotoxy ( aa_context* c, int x, int y ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_gotoxy(c, 8, 16); //target call

return 0;

}

[+] aa_hidecursor ( aa_context* c ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_hidecursor(c); //target call

return 0;

}

[+] aa_init ( struct aa_driver* driver, struct aa_hardware_params* defparams, void* driverdata ):aa_context*

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_init(&driver, &defparams, driverdata); //target call

return 0;

}

[+] aa_initkbd ( struct aa_context* context, struct aa_kbddriver* drv, int mode ):int

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11
12

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* context = aa_init(&driver, &defparams, driverdata);

struct aa_kbddriver drv = kbd_X11_d;

aa_initkbd(context, &drv, 0); //target call

return 0;

}

[+] aa_initmouse ( struct aa_context* c, struct aa_mousedriver* d, int mode ):int

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11
12

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

struct aa_mousedriver d = mouse_X11_d;

aa_initmouse(c, &d, 0); //target call

return 0;

}

[+] aa_puts ( aa_context* c, int x, int y, int attr, char* s ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_puts(

16,

"s"); //target call

return 0;

}

[+] aa_render ( aa_context* c, aa_renderparams* p, int x1, int y1, int x2, int y2 ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_renderparams* p = aa_getrenderparams();

aa_render(

16,

24,

32); //target call

return 0;

}

[+] aa_renderpalette ( aa_context* c, int* table, aa_renderparams* p, int x1, int y1, int x2, int y2 ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

int* table = (int*) malloc(sizeof(int)*256);

aa_renderparams* p = aa_getrenderparams();

aa_renderpalette(

table,

16,

24,

32); //target call

return 0;

}

[+] aa_resize ( aa_context* c ):int

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_resize(c); //target call

return 0;

}

[+] aa_resizehandler ( aa_context* c, void(*handler)(aa_context*) ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_resizehandler(c, &aa_close); //target call

return 0;

}

[+] aa_setfont ( aa_context* c, struct aa_font* font ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11
12

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

struct aa_font font = font8;

aa_setfont(c, &font); //target call

return 0;

}

[+] aa_setsupported ( aa_context* c, int supported ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_setsupported(c, 0); //target call

return 0;

}

[+] aa_showcursor ( aa_context* c ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* c = aa_init(&driver, &defparams, driverdata);

aa_showcursor(c); //target call

return 0;

}

[+] aa_uninitkbd ( struct aa_context* context ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* context = aa_init(&driver, &defparams, driverdata);

aa_uninitkbd(context); //target call

return 0;

}

[+] aa_uninitmouse ( struct aa_context* context ):void

Width?[80]Height?[32]

1
2
3
4
5
6
7
8
9
10
11

#include <aalib.h>

#include <stdlib.h>

int main(int argc, char *argv[])

{

struct aa_driver driver = X11_d;

struct aa_hardware_params defparams = aa_defparams;

void* driverdata = malloc(256);

aa_context* context = aa_init(&driver, &defparams, driverdata);

aa_uninitmouse(context); //target call

return 0;

}

to the top