Test results for the libart-2.3.16 library on x86

Summary

Total tests	108
Passed / Failed tests	97 / 11
Warnings	3
Verdict	Test Failed

Problem Summary

Received signal SEGV	10
Hanged execution	1

Failed Tests (11)

[+] Received signal SEGV (10 problems)

art_affine.h, libart_lgpl_2.so.2.3.16
[+] art_affine_point ( ArtPoint* dst, ArtPoint const* src, double const* affine ) : void

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <libart_lgpl/libart.h>
int main(int argc, char *argv[])
{
ArtPoint* dst = art_bezier_to_vec(
1.5,
2.5,
3.5,
4.5,
5.5,
6.5,
7.5,
8.5,
0,
1);
ArtPoint* src = art_bezier_to_vec(
9.5,
10.5,
11.5,
12.5,
13.5,
14.5,
15.5,
16.5,
0,
2);
double affine [] = {
17.5,
18.5,
19.5,
20.5};
art_affine_point(dst, src, affine); //target call
return 0;
}

[+] art_affine_to_string ( char* str, double const* src ) : void

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11

#include <libart_lgpl/libart.h>

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

{

double src [] = {

1.5,

2.5,

3.5,

4.5};

art_affine_to_string("str", src); //target call

return 0;

}

art_render_gradient.h, libart_lgpl_2.so.2.3.16
[+] art_render_gradient_linear ( ArtRender* render, ArtGradientLinear const* gradient, ArtFilterLevel level ) : void

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <libart_lgpl/libart.h>

#include <libart_lgpl/art_render_gradient.h>

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

{

art_u8 pixels [] = {

'A',

'B',

'C',

'D',

'\0'};

ArtAlphaGamma* alphagamma = art_alphagamma_new(1.5);

ArtRender* render = art_render_new(

16,

24,

32,

pixels,

ART_ALPHA_SEPARATE,

alphagamma);

ArtGradientLinear gradient = {

.a = 2.5,

.b = 3.5,

.c = 4.5,

.spread = ART_GRADIENT_PAD,

.n_stops = 4,

.stops = 0};

art_render_gradient_linear(render, &gradient, ART_FILTER_NEAREST); //target call

return 0;

}

[+] art_render_gradient_radial ( ArtRender* render, ArtGradientRadial const* gradient, ArtFilterLevel level ) : void

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

#include <libart_lgpl/libart.h>

#include <libart_lgpl/art_render_gradient.h>

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

{

art_u8 pixels [] = {

'A',

'B',

'C',

'D',

'\0'};

ArtAlphaGamma* alphagamma = art_alphagamma_new(1.5);

ArtRender* render = art_render_new(

16,

24,

32,

pixels,

ART_ALPHA_SEPARATE,

alphagamma);

ArtGradientRadial gradient = {

.affine = {

2.5,

3.5,

4.5,

5.5,

6.5,

7.5},

.fx = 8.5,

.fy = 9.5,

.n_stops = 4,

.stops = 0};

art_render_gradient_radial(render, &gradient, ART_FILTER_NEAREST); //target call

return 0;

}

art_rgb_pixbuf_affine.h, libart_lgpl_2.so.2.3.16
[+] art_rgb_pixbuf_affine ( art_u8* dst, int x0, int y0, int x1, int y1, int dst_rowstride, ArtPixBuf const* pixbuf, double const* affine, ArtFilterLevel level, ArtAlphaGamma* alphagamma ) : void

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include <libart_lgpl/libart.h>

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

{

art_u8 dst [] = {

'A',

'B',

'C',

'D',

'\0'};

ArtPixBuf* pixbuf = art_pixbuf_new_rgb(

dst,

40,

48,

0);

double affine [] = {

1.5,

2.5,

3.5,

4.5};

ArtAlphaGamma* alphagamma = art_alphagamma_new(5.5);

art_rgb_pixbuf_affine(

dst,

16,

24,

32,

pixbuf,

affine,

ART_FILTER_NEAREST,

alphagamma); //target call

return 0;

}

art_svp.h, libart_lgpl_2.so.2.3.16
[+] art_svp_add_segment ( ArtSVP** p_vp, int* pn_segs_max, int** pn_points_max, int n_points, int dir, ArtPoint* points, ArtDRect* bbox ) : int

received signal SEGV

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <libart_lgpl/libart.h>

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

{

ArtVpath* vpath = art_vpath_new_circle(1.5, 2.5, 3.5);

ArtSVP* p_vp = art_svp_from_vpath(vpath);

int pn_segs_max = 0;

int* pn_points_max [] = {

(int*) malloc(sizeof(int)*256),

0};

ArtPoint* points = art_bezier_to_vec(

4.5,

5.5,

6.5,

7.5,

8.5,

9.5,

10.5,

11.5,

2);

ArtDRect bbox = {

.x0 = 12.5,

.y0 = 13.5,

.x1 = 14.5,

.y1 = 15.5};

art_svp_add_segment(

(ArtSVP**)&p_vp,

&pn_segs_max,

pn_points_max,

points,

&bbox); //target call

return 0;

}

art_svp_intersect.h, libart_lgpl_2.so.2.3.16
[+] art_svp_intersector ( ArtSVP const* in, ArtSvpWriter* out ) : void

received signal SEGV

1
2
3
4
5
6
7
8
9
10

#include <libart_lgpl/libart.h>

#include <libart_lgpl/art_svp_intersect.h>

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

{

ArtVpath* vpath = art_vpath_new_circle(1.5, 2.5, 3.5);

ArtSVP* in = art_svp_from_vpath(vpath);

ArtSvpWriter out;

art_svp_intersector(in, &out); //target call

return 0;

}

[+] art_svp_seg_compare ( void const* s1, void const* s2 ) : int

received signal SEGV

1
2
3
4
5
6
7
8
9

#include <libart_lgpl/libart.h>

#include <libart_lgpl/art_svp_intersect.h>

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

{

void* s1 = malloc(256);

void* s2 = malloc(256);

art_svp_seg_compare(s1, s2); //target call

return 0;

}

art_vpath_bpath.h, libart_lgpl_2.so.2.3.16
[+] art_bez_path_to_vec ( ArtBpath const* bez, double flatness ) : ArtVpath*

received signal SEGV

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

#include <libart_lgpl/libart.h>

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

{

double matrix [] = {

1.5, 2.5, 3.5, 4.5,

5.5, 6.5, 7.5, 8.5,

9.5, 10.5, 11.5, 12.5,

13.5, 14.5, 15.5, 16.5};

ArtBpath* bez = art_bpath_affine_transform(0, matrix);

art_bez_path_to_vec(bez, 17.5); //target call

return 0;

}

[+] art_bezier_to_vec ( double x0, double y0, double x1, double y1, double x2, double y2, double x3, double y3, ArtPoint* p, int level ) : ArtPoint*

received signal SEGV

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

#include <libart_lgpl/libart.h>
int main(int argc, char *argv[])
{
ArtPoint p = {.x = 9.5, .y = 10.5};
art_bezier_to_vec(
1.5,
2.5,
3.5,
4.5,
5.5,
6.5,
7.5,
8.5,
&p,
1); //target call
return 0;
}

to the top

[+] Hanged execution (1 problem)

art_vpath_dash.h, libart_lgpl_2.so.2.3.16
[+] art_vpath_dash ( ArtVpath const* vpath, ArtVpathDash const* dash ) : ArtVpath*

hanged execution (more than 7 seconds)

1
2
3
4
5
6
7
8
9

#include <libart_lgpl/libart.h>

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

{

ArtVpath* vpath = art_vpath_new_circle(1.5, 2.5, 3.5);

double* dash_1 = (double*) malloc(sizeof(double)*256);

ArtVpathDash dash = {.offset = 4.5, .n_dash = 4, .dash = dash_1};

art_vpath_dash(vpath, &dash); //target call

return 0;

}

to the top

Warnings (3)

[+] Received signal ABRT (1 warning)

art_pixbuf.h, libart_lgpl_2.so.2.3.16
[+] art_pixbuf_free ( ArtPixBuf* pixbuf ) : void

received signal ABRT

*** glibc detected *** ./test: munmap_chunk(): invalid pointer: 0xbfc7edf7 ***
======= Backtrace: =========
/lib/libc.so.6(+0x6de2b)[0xb771ce2b]
/lib/libc.so.6(+0x6e5fe)[0xb771d5fe]
/home/andrey/upstream-tracker/testing/libart/2.3.16/lib/libart_lgpl_2.so.2(+0x3ec3)[0xb784fec3]
/home/andrey/upstream-tracker/testing/libart/2.3.16/lib/libart_lgpl_2.so.2(art_pixbuf_free+0x63)[0xb784ffc0]
./test[0x80485aa]
/lib/libc.so.6(__libc_start_main+0xfe)[0xb76c5c2e]
======= Memory map: ========
08048000-08049000 r-xp 00000000 08:02 18546773   /home/andrey/upstream-tracker/tests/libart/2.3.16/groups/art_pixbuf/functions/art_pixbuf_free/test
08049000-0804a000 r--p 00000000 08:02 18546773   /home/andrey/upstream-tracker/tests/libart/2.3.16/groups/art_pixbuf/functions/art_pixbuf_free/test
0804a000-0804b000 rw-p 00001000 08:02 18546773   /home/andrey/upstream-tracker/tests/libart/2.3.16/groups/art_pixbuf/functions/art_pixbuf_free/test
0804b000-0806c000 rw-p 00000000 00:00 0          [heap]
b7666000-b7682000 r-xp 00000000 08:01 16568      /lib/libgcc_s.so.1
b7682000-b7683000 r--p 0001b000 08:01 16568      /lib/libgcc_s.so.1
b7683000-b7684000 rw-p 0001c000 08:01 16568      /lib/libgcc_s.so.1
b7684000-b7 ...

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

#include <libart_lgpl/libart.h>

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

{

art_u8 pixels [] = {

'A',

'B',

'C',

'D',

'\0'};

ArtPixBuf* pixbuf = art_pixbuf_new_rgb(

pixels,

16,

0);

art_pixbuf_free(pixbuf); //target call

return 0;

}

to the top

[+] Unexpected Output (2 warnings)

art_render.h, libart_lgpl_2.so.2.3.16
[+] art_render_clear_rgb ( ArtRender* render, art_u32 clear_rgb ) : void

art_render_clear_rgb: called on render with 4 channels, only works with 3

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

#include <libart_lgpl/libart.h>

#include <libart_lgpl/art_render_svp.h>

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

{

art_u8 pixels [] = {

'A',

'B',

'C',

'D',

'\0'};

ArtAlphaGamma* alphagamma = art_alphagamma_new(1.5);

ArtRender* render = art_render_new(

16,

24,

32,

pixels,

ART_ALPHA_SEPARATE,

alphagamma);

art_render_clear_rgb(render, 5); //target call

return 0;

}

[+] art_render_invoke ( ArtRender* render ) : void

art_render_invoke: no image source given

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

#include <libart_lgpl/libart.h>

#include <libart_lgpl/art_render_svp.h>

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

{

art_u8 pixels [] = {

'A',

'B',

'C',

'D',

'\0'};

ArtAlphaGamma* alphagamma = art_alphagamma_new(1.5);

ArtRender* render = art_render_new(

16,

24,

32,

pixels,

ART_ALPHA_SEPARATE,

alphagamma);

art_render_invoke(render); //target call

return 0;

}

to the top