FANDOM


OpenSCAD test run report

Sysid: mac_64-bit_nvidia-geforce-gt_cdiv

Result summary: 364 / 364 tests passed ( 100 % )

System info:

OpenSCAD Version: test
Compiled by: GCC 4.2.1 (Apple Inc. build 5664)
Compile date: Dec  7 2011
Boost version: 1_47
Eigen version: 2.0.16
CGAL version: 3.9
OpenCSG version: OpenCSG 1.3.2
GLEW version: 1.7.0
GL Renderer: NVIDIA GeForce GT 330M OpenGL Engine
GL Vendor: NVIDIA Corporation
OpenGL Version: 2.1 NVIDIA-1.6.36
GL Extensions: 
GL_ARB_framebuffer_object: yes
GL_EXT_framebuffer_object: yes
GL_EXT_packed_depth_stencil: yes
FBO: RGBA(8888), depth(24), stencil(8)
GL context creator: Cocoa / CGL
PNG generator: Core Foundation
OS info: Mac OS X 10.6.8 (i386 kernel)
Machine: 64-bit

Git branch: master from origin git@github.com:openscad/openscad.git
Git upstream: 
Image comparison: ImageMagick

start time: Dec 07 22:25 CET
end time  : Dec 07 22:27 CET

Image tests

cgalpngtest_hull2-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest hull2-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output hull2-tests-actual
191/364 Testing: cgalpngtest_hull2-tests
191/364 Test: cgalpngtest_hull2-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/hull2-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_hull2-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=10); (34 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (36 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (36 verts)
CGAL Cache insert: group(){hull(){multmatrix([[1,0,0,15],[0 (36 verts)
reduce polygons: 30 -> 1
CGAL Cache insert: square(size=[2,2],center=false); (8 verts)
reduce polygons: 2 -> 1
reduce polygons: 2 -> 1
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (9 verts)
CGAL Cache insert: group(){hull(){multmatrix([[1,0,0,15],[0 (9 verts)
reduce polygons: 3 -> 1
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=3); (14 verts)
reduce polygons: 8 -> 1
reduce polygons: 8 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (14 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,10],[0,0,1, (14 verts)
reduce polygons: 8 -> 1
reduce polygons: 8 -> 1
CGAL Cache insert: multmatrix([[1,0,0,10],[0,1,0,0],[0,0,1, (14 verts)
CGAL Cache insert: multmatrix([[1,0,0,10],[0,1,0,10],[0,0,1 (14 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,0],[0,1,0,0], (24 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,10],[0,1,0,0] (24 verts)
CGAL Cache insert: hull(){group(){group(){multmatrix([[1,0, (16 verts)
CGAL Cache insert: group(){hull(){group(){group(){multmatri (16 verts)
reduce polygons: 10 -> 1
CGAL Cache insert: group(){hull(){multmatrix([[1,0,0,15],[0 (36 verts)
CGAL Cache insert: multmatrix([[1,0,0,40],[0,1,0,0],[0,0,1, (36 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-20],[0,0,1 (9 verts)
CGAL Cache insert: multmatrix([[1,0,0,30],[0,1,0,-25],[0,0, (16 verts)
CGAL Cache insert: group(){group(){hull(){multmatrix([[1,0, (85 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/hull2-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/hull2-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =  11.72 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_hull2-tests" end time: Dec 07 22:25 CET
"cgalpngtest_hull2-tests" time elapsed: 00:00:11


throwntogethertest_hull2-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest hull2-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output hull2-tests-actual
315/364 Testing: throwntogethertest_hull2-tests
315/364 Test: throwntogethertest_hull2-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/hull2-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_hull2-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=10); (34 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (36 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (36 verts)
CGAL Cache insert: square(size=[2,2],center=false); (8 verts)
reduce polygons: 2 -> 1
reduce polygons: 2 -> 1
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (9 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=3); (14 verts)
reduce polygons: 8 -> 1
reduce polygons: 8 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (14 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,10],[0,0,1, (14 verts)
reduce polygons: 8 -> 1
reduce polygons: 8 -> 1
CGAL Cache insert: multmatrix([[1,0,0,10],[0,1,0,0],[0,0,1, (14 verts)
CGAL Cache insert: multmatrix([[1,0,0,10],[0,1,0,10],[0,0,1 (14 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,0],[0,1,0,0], (24 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,10],[0,1,0,0] (24 verts)
CGAL Cache insert: hull(){group(){group(){multmatrix([[1,0, (16 verts)
Normalized CSG tree has 4 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/hull2-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/hull2-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   5.16 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_hull2-tests" end time: Dec 07 22:25 CET
"throwntogethertest_hull2-tests" time elapsed: 00:00:05


opencsgtest_hull2-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest hull2-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output hull2-tests-actual
251/364 Testing: opencsgtest_hull2-tests
251/364 Test: opencsgtest_hull2-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/hull2-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_hull2-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=10); (34 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (36 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (36 verts)
CGAL Cache insert: square(size=[2,2],center=false); (8 verts)
reduce polygons: 2 -> 1
reduce polygons: 2 -> 1
CGAL Cache insert: hull(){multmatrix([[1,0,0,15],[0,1,0,10] (9 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=3); (14 verts)
reduce polygons: 8 -> 1
reduce polygons: 8 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (14 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,10],[0,0,1, (14 verts)
reduce polygons: 8 -> 1
reduce polygons: 8 -> 1
CGAL Cache insert: multmatrix([[1,0,0,10],[0,1,0,0],[0,0,1, (14 verts)
CGAL Cache insert: multmatrix([[1,0,0,10],[0,1,0,10],[0,0,1 (14 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,0],[0,1,0,0], (24 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,10],[0,1,0,0] (24 verts)
CGAL Cache insert: hull(){group(){group(){multmatrix([[1,0, (16 verts)
Normalized CSG tree has 4 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/hull2-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/hull2-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =  12.04 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_hull2-tests" end time: Dec 07 22:25 CET
"opencsgtest_hull2-tests" time elapsed: 00:00:12


throwntogethertest_circle
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest circle-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output circle-actual
340/364 Testing: throwntogethertest_circle
340/364 Test: throwntogethertest_circle
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_circle" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/circle-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/circle-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.19 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_circle" end time: Dec 07 22:25 CET
"throwntogethertest_circle" time elapsed: 00:00:01


cgalpngtest_intersection_for-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest intersection for-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output intersection for-tests-actual
197/364 Testing: cgalpngtest_intersection_for-tests
197/364 Test: cgalpngtest_intersection_for-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/intersection_for-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_intersection_for-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: CGAL Cache insert: cube(size=[100,20,20],center=true); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[0.469846,0.882564,0.0180283 (8 verts)
CGAL Cache insert: multmatrix([[0.417218,0.668356,-0.615817 (8 verts)
CGAL Cache insert: multmatrix([[0.0190076,-0.601928,0.79832 (8 verts)
CGAL Cache insert: intersection(); (0 verts)
CGAL Cache insert: intersection(){multmatrix([[1,0,0,0],[0, (28 verts)
CGAL Cache insert: group(){intersection();intersection();in (28 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/intersection_for-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/intersection_for-tests-actual.png
<end of output>
Test time =   2.61 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_intersection_for-tests" end time: Dec 07 22:25 CET
"cgalpngtest_intersection_for-tests" time elapsed: 00:00:02


cgalpngtest_circle-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest circle-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output circle-tests-actual
185/364 Testing: cgalpngtest_circle-tests
185/364 Test: cgalpngtest_circle-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/circle-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_circle-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=1); (9 verts)
reduce polygons: 3 -> 1
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=3); (14 verts)
reduce polygons: 8 -> 1
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=0); (4 verts)
CGAL Cache insert: circle($fn=4,$fa=12,$fs=1,r=1); (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: circle($fn=8,$fa=12,$fs=1,r=1); (12 verts)
reduce polygons: 6 -> 1
CGAL Cache insert: circle($fn=12,$fa=12,$fs=1,r=1); (16 verts)
reduce polygons: 10 -> 1
CGAL Cache insert: circle($fn=0,$fa=20,$fs=0.3,r=1); (15 verts)
reduce polygons: 9 -> 1
CGAL Cache insert: circle($fn=0,$fa=30,$fs=0.3,r=1); (15 verts)
reduce polygons: 9 -> 1
CGAL Cache insert: circle($fn=0,$fa=40,$fs=0.3,r=1); (13 verts)
reduce polygons: 7 -> 1
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,3],[0,0,1,0 (9 verts)
CGAL Cache insert: multmatrix([[1,0,0,5],[0,1,0,1],[0,0,1,0 (14 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-1],[0,0,1, (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-3],[0,0,1, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,3],[0,1,0,-3],[0,0,1, (12 verts)
CGAL Cache insert: multmatrix([[1,0,0,6],[0,1,0,-3],[0,0,1, (16 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-6],[0,0,1, (15 verts)
CGAL Cache insert: multmatrix([[1,0,0,3],[0,1,0,-6],[0,0,1, (15 verts)
CGAL Cache insert: multmatrix([[1,0,0,6],[0,1,0,-6],[0,0,1, (13 verts)
CGAL Cache insert: group(){circle($fn=0,$fa=12,$fs=1,r=1);m (79 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/circle-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/circle-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   4.66 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_circle-tests" end time: Dec 07 22:25 CET
"cgalpngtest_circle-tests" time elapsed: 00:00:04


cgalpngtest_import_dxf-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest import dxf-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output import dxf-tests-actual
194/364 Testing: cgalpngtest_import_dxf-tests
194/364 Test: cgalpngtest_import_dxf-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/import_dxf-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_import_dxf-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: ERROR: Unsupported file format while trying to import file ''
reduce polygons: 6 -> 2
CGAL Cache insert: import(file="../../dxf/polygons.dxf",lay (14 verts)
reduce polygons: 6 -> 2
reduce polygons: 6 -> 2
CGAL Cache insert: import(file="../../dxf/polygons.dxf",lay (14 verts)
reduce polygons: 6 -> 2
reduce polygons: 6 -> 2
CGAL Cache insert: import(file="../../dxf/polygons.dxf",lay (14 verts)
reduce polygons: 6 -> 2
reduce polygons: 38 -> 3
reduce polygons: 2 -> 1
CGAL Cache insert: import(file="../../dxf/multiple-layers.d (8 verts)
reduce polygons: 2 -> 1
reduce polygons: 2 -> 1
reduce polygons: 28 -> 1
CGAL Cache insert: import(file="../../dxf/multiple-layers.d (34 verts)
reduce polygons: 28 -> 1
reduce polygons: 4 -> 1
CGAL Cache insert: import(file="../../dxf/multiple-layers.d (10 verts)
reduce polygons: 4 -> 1
CGAL Cache insert: import(file="",layer="",origin=[0,0],sca (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,-210],[0,1,0,0],[0,0, (14 verts)
CGAL Cache insert: multmatrix([[1,0,0,-210],[0,1,0,0],[0,0, (14 verts)
CGAL Cache insert: multmatrix([[1,0,0,-210],[0,1,0,0],[0,0, (14 verts)
CGAL Cache insert: import(file="../../dxf/multiple-layers.d (44 verts)
CGAL Cache insert: multmatrix([[1,0,0,-200],[0,1,0,200],[0, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,200],[0,0,1 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,200],[0,1,0,200],[0,0 (34 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,200],[0,0,1 (10 verts)
CGAL Cache insert: group(){import(file="",layer="",origin=[ (114 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/import_dxf-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/import_dxf-tests-actual.png
<end of output>
Test time =   5.89 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_import_dxf-tests" end time: Dec 07 22:25 CET
"cgalpngtest_import_dxf-tests" time elapsed: 00:00:05


cgalpngtest_2d-3d
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest 2d-3d-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output 2d-3d-actual
181/364 Testing: cgalpngtest_2d-3d
181/364 Test: cgalpngtest_2d-3d
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/2d-3d.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_2d-3d" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: square(size=[1,1],center=false); (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: cube(size=[1,1,1],center=false); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: group(){cube(size=[1,1,1],center=false); (8 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/2d-3d-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/2d-3d-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.92 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_2d-3d" end time: Dec 07 22:25 CET
"cgalpngtest_2d-3d" time elapsed: 00:00:01


cgalpngtest_linear_extrude-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest linear extrude-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output linear extrude-tests-actual
198/364 Testing: cgalpngtest_linear_extrude-tests
198/364 Test: cgalpngtest_linear_extrude-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/linear_extrude-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_linear_extrude-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cube(size=[1,1,1],center=false); (8 verts)
ERROR: rotate_extrude() is not defined for 3D child objects!
CGAL Cache insert: square(size=[10,10],center=false); (8 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=3); (14 verts)
CGAL Cache insert: difference(){circle($fn=0,$fa=12,$fs=1,r (30 verts)
CGAL Cache insert: linear_extrude(height=10,center=true,con (52 verts)
CGAL Cache insert: polygon(points=[[-5,-2.5],[5,-2.5],[0,2. (7 verts)
CGAL Cache insert: linear_extrude(height=10,center=false,co (12 verts)
CGAL Cache insert: linear_extrude(height=20,center=false,co (12 verts)
CGAL Cache insert: linear_extrude(height=20,center=false,co (44 verts)
CGAL Cache insert: rotate_extrude(convexity=1,$fn=0,$fa=12, (0 verts)
CGAL Cache insert: rotate_extrude(convexity=1,$fn=0,$fa=12, (0 verts)
CGAL Cache insert: linear_extrude(height=10,center=false,co (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,19],[0,1,0,5],[0,0,1, (52 verts)
CGAL Cache insert: multmatrix([[1,0,0,31.5],[0,1,0,2.5],[0, (12 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,20],[0,0,1, (12 verts)
CGAL Cache insert: multmatrix([[1,0,0,19],[0,1,0,20],[0,0,1 (44 verts)
CGAL Cache insert: group(){rotate_extrude(convexity=1,$fn=0 (128 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/linear_extrude-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/linear_extrude-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   7.29 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_linear_extrude-tests" end time: Dec 07 22:25 CET
"cgalpngtest_linear_extrude-tests" time elapsed: 00:00:07


cgalpngtest_assign-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest assign-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output assign-tests-actual
182/364 Testing: cgalpngtest_assign-tests
182/364 Test: cgalpngtest_assign-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/assign-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_assign-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cube(size=[0,0,0],center=false); (0 verts)
CGAL Cache insert: group(){cube(size=[0,0,0],center=false); (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-5],[0,0,1, (0 verts)
CGAL Cache insert: cube(size=[0.5,0.5,0.5],center=false); (8 verts)
CGAL Cache insert: group(){cube(size=[0.5,0.5,0.5],center=f (8 verts)
CGAL Cache insert: cube(size=[1,1,1],center=false); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-5],[0,0,1, (8 verts)
CGAL Cache insert: group(){cube(size=[1,1,1],center=false); (8 verts)
CGAL Cache insert: cube(size=[2,2,2],center=false); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-5],[0,0,1, (8 verts)
CGAL Cache insert: cube(size=[1.5,1.5,1.5],center=false); (8 verts)
CGAL Cache insert: group(){cube(size=[1.5,1.5,1.5],center=f (8 verts)
CGAL Cache insert: cube(size=[3,3,3],center=false); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-5],[0,0,1, (8 verts)
CGAL Cache insert: group(){cube(size=[2,2,2],center=false); (8 verts)
CGAL Cache insert: cube(size=[4,4,4],center=false); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-5],[0,0,1, (8 verts)
CGAL Cache insert: cube(size=[2.5,2.5,2.5],center=false); (8 verts)
CGAL Cache insert: group(){cube(size=[2.5,2.5,2.5],center=f (8 verts)
CGAL Cache insert: cube(size=[5,5,5],center=false); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-5],[0,0,1, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,0.5],[0,1,0,0],[0,0,1 (16 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,0],[0,0,1,0 (16 verts)
CGAL Cache insert: multmatrix([[1,0,0,4.5],[0,1,0,0],[0,0,1 (16 verts)
CGAL Cache insert: multmatrix([[1,0,0,8],[0,1,0,0],[0,0,1,0 (16 verts)
CGAL Cache insert: multmatrix([[1,0,0,12.5],[0,1,0,0],[0,0, (16 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,0],[0,1,0,0], (80 verts)
CGAL Cache insert: group(){group(){multmatrix([[1,0,0,0],[0 (80 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/assign-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/assign-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   4.56 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_assign-tests" end time: Dec 07 22:25 CET
"cgalpngtest_assign-tests" time elapsed: 00:00:04


cgalpngtest_background-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest background-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output background-modifier-actual
183/364 Testing: cgalpngtest_background-modifier
183/364 Test: cgalpngtest_background-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/background-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_background-modifier" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: CGAL Cache insert: sphere($fn=0,$fa=12,$fs=1,r=10); (450 verts)
CGAL Cache insert: difference(){sphere($fn=0,$fa=12,$fs=1,r (450 verts)
CGAL Cache insert: group(){difference(){sphere($fn=0,$fa=12 (450 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/background-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/background-modifier-actual.png
<end of output>
Test time =   4.26 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_background-modifier" end time: Dec 07 22:25 CET
"cgalpngtest_background-modifier" time elapsed: 00:00:04


cgalpngtest_color-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest color-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output color-tests-actual
186/364 Testing: cgalpngtest_color-tests
186/364 Test: cgalpngtest_color-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/color-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_color-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cube(size=[10,10,10],center=false); (8 verts)
CGAL Cache insert: group(){cube(size=[10,10,10],center=fals (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,24],[0,1,0,12],[0,0,1 (8 verts)
CGAL Cache insert: color([0.501961,0,0.501961,1]){group(){c (8 verts)
CGAL Cache insert: color([0,0,1,0.5]){group(){cube(size=[10 (8 verts)
CGAL Cache insert: color([0,0.501961,0,0.2]){group(){cube(s (8 verts)
CGAL Cache insert: color([-1,-1,-1,1]){group(){cube(size=[1 (8 verts)
CGAL Cache insert: color([-1,-1,-1,0.5]){group(){cube(size= (8 verts)
CGAL Cache insert: color([-1,-1,-1,1]); (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,12],[0,1,0,12],[0,0,1 (8 verts)
CGAL Cache insert: color([1,0,0,1]){multmatrix([[1,0,0,24], (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,12],[0,0,1, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,12],[0,1,0,0],[0,0,1, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,24],[0,1,0,0],[0,0,1, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,-12],[0,1,0,12],[0,0, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,-12],[0,1,0,0],[0,0,1 (8 verts)
CGAL Cache insert: group(){color([-1,-1,-1,1]);color([-1,-1 (64 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/color-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/color-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   3.96 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_color-tests" end time: Dec 07 22:25 CET
"cgalpngtest_color-tests" time elapsed: 00:00:03


cgalpngtest_cube-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest cube-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output cube-tests-actual
187/364 Testing: cgalpngtest_cube-tests
187/364 Test: cgalpngtest_cube-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/cube-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_cube-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: CGAL Cache insert: cube(size=[2,3,1],center=false); (8 verts)
CGAL Cache insert: cube(size=[2,4,2],center=true); (8 verts)
CGAL Cache insert: cube(size=[1,1,1],center=false); (8 verts)
CGAL Cache insert: cube(size=[1,1,0],center=false); (0 verts)
CGAL Cache insert: cube(size=[1,0,1],center=false); (0 verts)
CGAL Cache insert: cube(size=[0,1,1],center=false); (0 verts)
CGAL Cache insert: cube(size=[0,0,0],center=false); (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,6],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: group(){cube(size=[1,1,1],center=false); (24 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/cube-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/cube-tests-actual.png
<end of output>
Test time =   1.72 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_cube-tests" end time: Dec 07 22:25 CET
"cgalpngtest_cube-tests" time elapsed: 00:00:01


cgalpngtest_disable-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest disable-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output disable-modifier-actual
189/364 Testing: cgalpngtest_disable-modifier
189/364 Test: cgalpngtest_disable-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/disable-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_disable-modifier" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=30,r1=6,r2 (38 verts)
CGAL Cache insert: difference(){cylinder($fn=0,$fa=12,$fs=1 (38 verts)
CGAL Cache insert: group(){difference(){cylinder($fn=0,$fa= (38 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/disable-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/disable-modifier-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.22 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_disable-modifier" end time: Dec 07 22:25 CET
"cgalpngtest_disable-modifier" time elapsed: 00:00:01


cgalpngtest_transform-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest transform-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output transform-tests-actual
206/364 Testing: cgalpngtest_transform-tests
206/364 Test: cgalpngtest_transform-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/transform-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_transform-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=20,r1=10,r (31 verts)
CGAL Cache insert: group(){cylinder($fn=0,$fa=12,$fs=1,h=20 (31 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,2,0,0],[0,0,0.5 (31 verts)
CGAL Cache insert: multmatrix([[0.5,0,0,0],[0,0.5,0,0],[0,0 (31 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,2.22045e-16,-1, (31 verts)
CGAL Cache insert: multmatrix([[0.707107,-1.11022e-16,0.707 (31 verts)
CGAL Cache insert: multmatrix([[1,0,0,25],[0,1,0,0],[0,0,1, (31 verts)
CGAL Cache insert: multmatrix([[1,0,0,20],[0,1,0,-30],[0,0, (31 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-20],[0,0,1 (31 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-40],[0,0,1 (31 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,0.707107,0.7071 (31 verts)
CGAL Cache insert: multmatrix([[1,0,0,-25],[0,1,0,0],[0,0,1 (31 verts)
CGAL Cache insert: multmatrix([[1,0.4,0.1,-25],[0.4,0.8,0,- (31 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,25],[0,1,0,0] (246 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/transform-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/transform-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =  12.64 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_transform-tests" end time: Dec 07 22:25 CET
"cgalpngtest_transform-tests" time elapsed: 00:00:12


cgalpngtest_ifelse-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest ifelse-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output ifelse-tests-actual
193/364 Testing: cgalpngtest_ifelse-tests
193/364 Test: cgalpngtest_ifelse-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/ifelse-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_ifelse-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: WARNING: Ignoring unknown variable 'ILLEGAL'.
CGAL Cache insert: cube(size=[2,2,2],center=true); (8 verts)
CGAL Cache insert: group(){cube(size=[2,2,2],center=true);} (8 verts)
CGAL Cache insert: group(){group(){cube(size=[2,2,2],center (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,3],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,3],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,3],[0,1,0,3],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,6],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,6],[0,1,0,3],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,9],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,9],[0,1,0,3],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,12],[0,1,0,0],[0,0,1, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,12],[0,1,0,3],[0,0,1, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,15],[0,1,0,0],[0,0,1, (8 verts)
CGAL Cache insert: group(){group(){cube(size=[2,2,2],center (88 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/ifelse-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/ifelse-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   6.85 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_ifelse-tests" end time: Dec 07 22:25 CET
"cgalpngtest_ifelse-tests" time elapsed: 00:00:06


cgalpngtest_highlight-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest highlight-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output highlight-modifier-actual
190/364 Testing: cgalpngtest_highlight-modifier
190/364 Test: cgalpngtest_highlight-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/highlight-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_highlight-modifier" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: sphere($fn=0,$fa=12,$fs=1,r=10); (450 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=30,r1=6,r2 (38 verts)
CGAL Cache insert: difference(){sphere($fn=0,$fa=12,$fs=1,r (422 verts)
CGAL Cache insert: group(){difference(){sphere($fn=0,$fa=12 (422 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/highlight-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/highlight-modifier-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   8.87 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_highlight-modifier" end time: Dec 07 22:25 CET
"cgalpngtest_highlight-modifier" time elapsed: 00:00:08


cgalpngtest_root-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest root-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output root-modifier-actual
203/364 Testing: cgalpngtest_root-modifier
203/364 Test: cgalpngtest_root-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/root-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_root-modifier" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=30,r1=6,r2 (38 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/root-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/root-modifier-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.14 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_root-modifier" end time: Dec 07 22:25 CET
"cgalpngtest_root-modifier" time elapsed: 00:00:01


cgalpngtest_cylinder-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest cylinder-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output cylinder-tests-actual
188/364 Testing: cgalpngtest_cylinder-tests
188/364 Test: cgalpngtest_cylinder-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/cylinder-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_cylinder-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=1,r1=0,r2= (0 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=1,r1=5,r2= (32 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=10,r1=5,r2 (32 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=5,r1=5,r2= (32 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=5,r1=5,r2= (17 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=8,r1=5,r2= (32 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=5,r1=0,r2= (17 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=15,r1=5,r2 (32 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=1,r1=1,r2= (10 verts)
CGAL Cache insert: multmatrix([[1,0,0,1],[0,1,0,0],[0,0,1,0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,0],[0,0,1,0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-11],[0,0,1 (32 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,11],[0,0,1, (32 verts)
CGAL Cache insert: multmatrix([[1,0,0,11],[0,1,0,-11],[0,0, (32 verts)
CGAL Cache insert: multmatrix([[1,0,0,11],[0,1,0,0],[0,0,1, (17 verts)
CGAL Cache insert: multmatrix([[1,0,0,11],[0,1,0,11],[0,0,1 (32 verts)
CGAL Cache insert: multmatrix([[1,0,0,22],[0,1,0,-11],[0,0, (17 verts)
CGAL Cache insert: multmatrix([[1,0,0,22],[0,1,0,0],[0,0,1, (17 verts)
CGAL Cache insert: multmatrix([[1,0,0,22],[0,1,0,11],[0,0,1 (32 verts)
CGAL Cache insert: group(){cylinder($fn=0,$fa=12,$fs=1,h=1, (221 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/cylinder-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/cylinder-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =  10.74 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_cylinder-tests" end time: Dec 07 22:25 CET
"cgalpngtest_cylinder-tests" time elapsed: 00:00:10


cgalpngtest_minkowski2-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest minkowski2-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output minkowski2-tests-actual
199/364 Testing: cgalpngtest_minkowski2-tests
199/364 Test: cgalpngtest_minkowski2-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/minkowski2-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_minkowski2-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: square(size=[10,10],center=true); (8 verts)
CGAL Cache insert: square(size=[8,8],center=true); (8 verts)
CGAL Cache insert: difference(){square(size=[10,10],center= (12 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=2); (11 verts)
CGAL Cache insert: minkowski(convexity=0){difference(){squa (15 verts)
CGAL Cache insert: group(){minkowski(convexity=0){differenc (15 verts)
reduce polygons: 9 -> 1
CGAL Cache insert: square(size=[10,10],center=false); (8 verts)
CGAL Cache insert: square(size=[5,5],center=false); (8 verts)
CGAL Cache insert: difference(){square(size=[10,10],center= (10 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: minkowski(convexity=0){difference(){squa (28 verts)
CGAL Cache insert: group(){minkowski(convexity=0){differenc (28 verts)
reduce polygons: 22 -> 1
CGAL Cache insert: minkowski(convexity=0){square(size=[10,1 (24 verts)
CGAL Cache insert: group(){minkowski(convexity=0){square(si (24 verts)
reduce polygons: 18 -> 1
CGAL Cache insert: multmatrix([[1,0,0,-20],[0,1,0,5],[0,0,1 (14 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (28 verts)
CGAL Cache insert: multmatrix([[1,0,0,25],[0,1,0,0],[0,0,1, (24 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,-20],[0,1,0,5 (58 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/minkowski2-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/minkowski2-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   3.07 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_minkowski2-tests" end time: Dec 07 22:25 CET
"cgalpngtest_minkowski2-tests" time elapsed: 00:00:03


cgalpngtest_include-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest include-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output include-tests-actual
196/364 Testing: cgalpngtest_include-tests
196/364 Test: cgalpngtest_include-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/include-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_include-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: WARNING: Can't open input file `non-file'.
CGAL Cache insert: cube(size=[1,1,1],center=true); (8 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=1,r1=0.7,r (10 verts)
CGAL Cache insert: group(){cylinder($fn=0,$fa=12,$fs=1,h=1, (10 verts)
CGAL Cache insert: cylinder($fn=10,$fa=12,$fs=1,h=1,r1=0.5, (20 verts)
CGAL Cache insert: group(){cylinder($fn=10,$fa=12,$fs=1,h=1 (20 verts)
CGAL Cache insert: sphere($fn=8,$fa=12,$fs=1,r=0.5); (32 verts)
CGAL Cache insert: group(){sphere($fn=8,$fa=12,$fs=1,r=0.5) (32 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=2,r1=0.4,r (10 verts)
CGAL Cache insert: difference(){cube(size=[1,1,1],center=tr (18 verts)
CGAL Cache insert: group(){difference(){cube(size=[1,1,1],c (18 verts)
CGAL Cache insert: sphere($fn=16,$fa=12,$fs=1,r=0.7); (128 verts)
CGAL Cache insert: group(){cube(size=[1,1,1],center=true);} (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,0],[0,0,1,0 (10 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,-2],[0,0,1, (20 verts)
CGAL Cache insert: multmatrix([[1,0,0,-2],[0,1,0,0],[0,0,1, (32 verts)
CGAL Cache insert: multmatrix([[1,0,0,-2],[0,1,0,-2],[0,0,1 (18 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-2],[0,0,1, (128 verts)
CGAL Cache insert: group(){group(){cube(size=[1,1,1],center (216 verts)
CGAL Cache insert: group(){group(){group(){cube(size=[1,1,1 (216 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/include-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/include-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   8.21 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_include-tests" end time: Dec 07 22:25 CET
"cgalpngtest_include-tests" time elapsed: 00:00:08


cgalpngtest_square-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest square-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output square-tests-actual
205/364 Testing: cgalpngtest_square-tests
205/364 Test: cgalpngtest_square-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/square-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_square-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: square(size=[1,1],center=true); (8 verts)
reduce polygons: 2 -> 1
reduce polygons: 2 -> 1
CGAL Cache insert: square(size=[0,0],center=true); (0 verts)
CGAL Cache insert: square(size=[1,0],center=true); (0 verts)
CGAL Cache insert: square(size=[0,1],center=true); (0 verts)
CGAL Cache insert: square(size=[1,2],center=true); (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: square(size=[2,1],center=true); (8 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: square(size=[1,1],center=false); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,4],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,6],[0,1,0,0],[0,0,1,0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,2],[0,0,1,0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,2],[0,0,1,0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,4],[0,1,0,2],[0,0,1,0 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,6],[0,1,0,2],[0,0,1,0 (8 verts)
CGAL Cache insert: group(){square(size=[1,1],center=false); (24 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/square-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/square-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   2.05 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_square-tests" end time: Dec 07 22:25 CET
"cgalpngtest_square-tests" time elapsed: 00:00:02


cgalpngtest_ellipse-arc
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest ellipse-arc-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output ellipse-arc-actual
214/364 Testing: cgalpngtest_ellipse-arc
214/364 Test: cgalpngtest_ellipse-arc
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-arc.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_ellipse-arc" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 7 -> 1
CGAL Cache insert: import(file="../../dxf/ellipse-arc.dxf", (13 verts)
CGAL Cache insert: group(){import(file="../../dxf/ellipse-a (13 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/ellipse-arc-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/ellipse-arc-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.20 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_ellipse-arc" end time: Dec 07 22:25 CET
"cgalpngtest_ellipse-arc" time elapsed: 00:00:01


cgalpngtest_ellipse-arc-rot
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest ellipse-arc-rot-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output ellipse-arc-rot-actual
213/364 Testing: cgalpngtest_ellipse-arc-rot
213/364 Test: cgalpngtest_ellipse-arc-rot
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-arc-rot.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_ellipse-arc-rot" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 63 -> 4
CGAL Cache insert: import(file="../../dxf/ellipse-arc-rot.d (75 verts)
CGAL Cache insert: group(){import(file="../../dxf/ellipse-a (75 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/ellipse-arc-rot-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/ellipse-arc-rot-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   2.22 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_ellipse-arc-rot" end time: Dec 07 22:25 CET
"cgalpngtest_ellipse-arc-rot" time elapsed: 00:00:02


cgalpngtest_circle-double
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest circle-double-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output circle-double-actual
210/364 Testing: cgalpngtest_circle-double
210/364 Test: cgalpngtest_circle-double
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle-double.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_circle-double" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 34 -> 2
CGAL Cache insert: import(file="../../dxf/circle-double.dxf (38 verts)
CGAL Cache insert: group(){import(file="../../dxf/circle-do (38 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/circle-double-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/circle-double-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.92 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_circle-double" end time: Dec 07 22:26 CET
"cgalpngtest_circle-double" time elapsed: 00:00:01


cgalpngtest_union-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest union-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output union-tests-actual
207/364 Testing: cgalpngtest_union-tests
207/364 Test: cgalpngtest_union-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/union-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_union-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cube(size=[2,2,10],center=false); (8 verts)
CGAL Cache insert: cube(size=[10,10,10],center=false); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,4],[0,1,0,4],[0,0,1,8 (8 verts)
CGAL Cache insert: union(){cube(size=[10,10,10],center=fals (16 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,1 (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,1 (8 verts)
CGAL Cache insert: union(){cube(size=[10,10,10],center=fals (16 verts)
CGAL Cache insert: multmatrix([[1,0,0,4],[0,1,0,4],[0,0,1,1 (8 verts)
CGAL Cache insert: union(){cube(size=[10,10,10],center=fals (16 verts)
CGAL Cache insert: multmatrix([[1,0,0,-2],[0,1,0,10],[0,0,1 (8 verts)
CGAL Cache insert: union(){cube(size=[10,10,10],center=fals (15 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,10],[0,0,1, (8 verts)
CGAL Cache insert: union(){cube(size=[10,10,10],center=fals (15 verts)
CGAL Cache insert: multmatrix([[1,0,0,-12],[0,1,0,0],[0,0,1 (16 verts)
CGAL Cache insert: union(){cube(size=[10,10,10],center=fals (14 verts)
CGAL Cache insert: multmatrix([[1,0,0,12],[0,1,0,0],[0,0,1, (16 verts)
CGAL Cache insert: multmatrix([[1,0,0,24],[0,1,0,0],[0,0,1, (16 verts)
CGAL Cache insert: multmatrix([[1,0,0,-12],[0,1,0,12],[0,0, (15 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,12],[0,0,1, (15 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,-12],[0,1,0,0 (92 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/union-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/union-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   6.01 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_union-tests" end time: Dec 07 22:26 CET
"cgalpngtest_union-tests" time elapsed: 00:00:06


cgalpngtest_circle-small
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest circle-small-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output circle-small-actual
211/364 Testing: cgalpngtest_circle-small
211/364 Test: cgalpngtest_circle-small
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle-small.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_circle-small" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: reduce polygons: 56 -> 2
CGAL Cache insert: import(file="../../dxf/circle-small.dxf" (60 verts)
CGAL Cache insert: group(){import(file="../../dxf/circle-sm (60 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/circle-small-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/circle-small-actual.png
<end of output>
Test time =   1.83 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_circle-small" end time: Dec 07 22:26 CET
"cgalpngtest_circle-small" time elapsed: 00:00:01


cgalpngtest_ellipse-reverse
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest ellipse-reverse-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output ellipse-reverse-actual
215/364 Testing: cgalpngtest_ellipse-reverse
215/364 Test: cgalpngtest_ellipse-reverse
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-reverse.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_ellipse-reverse" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 29 -> 2
CGAL Cache insert: import(file="../../dxf/ellipse-reverse.d (37 verts)
CGAL Cache insert: group(){import(file="../../dxf/ellipse-r (37 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/ellipse-reverse-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/ellipse-reverse-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.67 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_ellipse-reverse" end time: Dec 07 22:26 CET
"cgalpngtest_ellipse-reverse" time elapsed: 00:00:01


cgalpngtest_circle-advanced
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest circle-advanced-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output circle-advanced-actual
209/364 Testing: cgalpngtest_circle-advanced
209/364 Test: cgalpngtest_circle-advanced
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle-advanced.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_circle-advanced" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: reduce polygons: 300 -> 7
CGAL Cache insert: import(file="../../dxf/circle-advanced.d (290 verts)
CGAL Cache insert: group(){import(file="../../dxf/circle-ad (290 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/circle-advanced-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/circle-advanced-actual.png
<end of output>
Test time =   6.43 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_circle-advanced" end time: Dec 07 22:26 CET
"cgalpngtest_circle-advanced" time elapsed: 00:00:06


cgalpngtest_lwpolyline-closed
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest lwpolyline-closed-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output lwpolyline-closed-actual
218/364 Testing: cgalpngtest_lwpolyline-closed
218/364 Test: cgalpngtest_lwpolyline-closed
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/lwpolyline-closed.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_lwpolyline-closed" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: import(file="../../dxf/lwpolyline-closed (7 verts)
CGAL Cache insert: group(){import(file="../../dxf/lwpolylin (7 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/lwpolyline-closed-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/lwpolyline-closed-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.20 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_lwpolyline-closed" end time: Dec 07 22:26 CET
"cgalpngtest_lwpolyline-closed" time elapsed: 00:00:01


cgalpngtest_ellipse-rot
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest ellipse-rot-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output ellipse-rot-actual
216/364 Testing: cgalpngtest_ellipse-rot
216/364 Test: cgalpngtest_ellipse-rot
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-rot.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_ellipse-rot" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: reduce polygons: 112 -> 4
CGAL Cache insert: import(file="../../dxf/ellipse-rot.dxf", (124 verts)
CGAL Cache insert: group(){import(file="../../dxf/ellipse-r (124 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/ellipse-rot-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/ellipse-rot-actual.png
<end of output>
Test time =   2.47 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_ellipse-rot" end time: Dec 07 22:26 CET
"cgalpngtest_ellipse-rot" time elapsed: 00:00:02


cgalpngtest_lwpolyline2
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest lwpolyline2-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output lwpolyline2-actual
220/364 Testing: cgalpngtest_lwpolyline2
220/364 Test: cgalpngtest_lwpolyline2
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/lwpolyline2.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_lwpolyline2" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: reduce polygons: 14 -> 1
CGAL Cache insert: import(file="../../dxf/lwpolyline2.dxf", (20 verts)
CGAL Cache insert: group(){import(file="../../dxf/lwpolylin (20 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/lwpolyline2-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/lwpolyline2-actual.png
<end of output>
Test time =   1.38 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_lwpolyline2" end time: Dec 07 22:26 CET
"cgalpngtest_lwpolyline2" time elapsed: 00:00:01


cgalpngtest_arc
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest arc-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output arc-actual
208/364 Testing: cgalpngtest_arc
208/364 Test: cgalpngtest_arc
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/arc.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_arc" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: reduce polygons: 8 -> 1
CGAL Cache insert: import(file="../../dxf/arc.dxf",layer="" (14 verts)
CGAL Cache insert: group(){import(file="../../dxf/arc.dxf", (14 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/arc-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/arc-actual.png
<end of output>
Test time =   1.03 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_arc" end time: Dec 07 22:26 CET
"cgalpngtest_arc" time elapsed: 00:00:01


cgalpngtest_circle
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest circle-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output circle-actual
212/364 Testing: cgalpngtest_circle
212/364 Test: cgalpngtest_circle
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_circle" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 28 -> 1
CGAL Cache insert: import(file="../../dxf/circle.dxf",layer (34 verts)
CGAL Cache insert: group(){import(file="../../dxf/circle.dx (34 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/circle-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/circle-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.24 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_circle" end time: Dec 07 22:26 CET
"cgalpngtest_circle" time elapsed: 00:00:01


cgalpngtest_lwpolyline
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest lwpolyline-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output lwpolyline-actual
219/364 Testing: cgalpngtest_lwpolyline
219/364 Test: cgalpngtest_lwpolyline
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/lwpolyline.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_lwpolyline" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: CGAL Cache insert: import(file="../../dxf/lwpolyline.dxf",l (7 verts)
CGAL Cache insert: group(){import(file="../../dxf/lwpolylin (7 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/lwpolyline-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/lwpolyline-actual.png
<end of output>
Test time =   1.02 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_lwpolyline" end time: Dec 07 22:26 CET
"cgalpngtest_lwpolyline" time elapsed: 00:00:01


cgalpngtest_ellipse
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest ellipse-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output ellipse-actual
217/364 Testing: cgalpngtest_ellipse
217/364 Test: cgalpngtest_ellipse
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_ellipse" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 28 -> 1
CGAL Cache insert: import(file="../../dxf/ellipse.dxf",laye (34 verts)
CGAL Cache insert: group(){import(file="../../dxf/ellipse.d (34 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/ellipse-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/ellipse-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.33 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_ellipse" end time: Dec 07 22:26 CET
"cgalpngtest_ellipse" time elapsed: 00:00:01


cgalpngtest_child-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest child-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output child-tests-actual
184/364 Testing: cgalpngtest_child-tests
184/364 Test: cgalpngtest_child-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/child-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_child-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: sphere($fn=16,$fa=12,$fs=1,r=1); (128 verts)
CGAL Cache insert: cylinder($fn=16,$fa=12,$fs=1,h=2,r1=1,r2 (32 verts)
CGAL Cache insert: cube(size=[2,2,2],center=true); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (128 verts)
CGAL Cache insert: multmatrix([[1,0,0,2.5],[0,1,0,0],[0,0,1 (32 verts)
CGAL Cache insert: multmatrix([[1,0,0,5],[0,1,0,0],[0,0,1,0 (8 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,0],[0,1,0,0], (168 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,0],[0,0,1,0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,2.5],[0,1,0,0],[0,0,1 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,5],[0,1,0,0],[0,0,1,0 (0 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,0],[0,1,0,0], (0 verts)
CGAL Cache insert: group(){multmatrix([[1,0,0,0],[0,1,0,0], (128 verts)
CGAL Cache insert: group(){group(){multmatrix([[1,0,0,0],[0 (128 verts)
CGAL Cache insert: group(){cylinder($fn=16,$fa=12,$fs=1,h=2 (32 verts)
CGAL Cache insert: group(); (0 verts)
CGAL Cache insert: group(){group(){multmatrix([[1,0,0,0],[0 (168 verts)
CGAL Cache insert: group(){group(){multmatrix([[1,0,0,0],[0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,3],[0,0,1,0 (128 verts)
CGAL Cache insert: multmatrix([[1,0,0,2.5],[0,1,0,3],[0,0,1 (32 verts)
CGAL Cache insert: multmatrix([[1,0,0,5],[0,1,0,3],[0,0,1,0 (0 verts)
CGAL Cache insert: group(){group(){group(){multmatrix([[1,0 (328 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/child-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/child-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =  11.80 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_child-tests" end time: Dec 07 22:26 CET
"cgalpngtest_child-tests" time elapsed: 00:00:11


cgalpngtest_multiple-layers
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest multiple-layers-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output multiple-layers-actual
221/364 Testing: cgalpngtest_multiple-layers
221/364 Test: cgalpngtest_multiple-layers
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/multiple-layers.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_multiple-layers" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 38 -> 3
CGAL Cache insert: import(file="../../dxf/multiple-layers.d (44 verts)
CGAL Cache insert: group(){import(file="../../dxf/multiple- (44 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/multiple-layers-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/multiple-layers-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.52 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_multiple-layers" end time: Dec 07 22:26 CET
"cgalpngtest_multiple-layers" time elapsed: 00:00:01


cgalpngtest_triangle-with-duplicate-vertex
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest triangle-with-duplicate-vertex-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output triangle-with-duplicate-vertex-actual
236/364 Testing: cgalpngtest_triangle-with-duplicate-vertex
236/364 Test: cgalpngtest_triangle-with-duplicate-vertex
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/triangle-with-duplicate-vertex.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_triangle-with-duplicate-vertex" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: import(file="../../dxf/triangle-with-dup (7 verts)
CGAL Cache insert: group(){import(file="../../dxf/triangle- (7 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/triangle-with-duplicate-vertex-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/triangle-with-duplicate-vertex-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.02 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_triangle-with-duplicate-vertex" end time: Dec 07 22:26 CET
"cgalpngtest_triangle-with-duplicate-vertex" time elapsed: 00:00:01


cgalpngtest_transform-insert
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest transform-insert-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output transform-insert-actual
235/364 Testing: cgalpngtest_transform-insert
235/364 Test: cgalpngtest_transform-insert
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/transform-insert.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_transform-insert" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 54 -> 3
CGAL Cache insert: import(file="../../dxf/transform-insert. (64 verts)
CGAL Cache insert: group(){import(file="../../dxf/transform (64 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/transform-insert-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/transform-insert-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.41 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_transform-insert" end time: Dec 07 22:26 CET
"cgalpngtest_transform-insert" time elapsed: 00:00:01


cgalpngtest_rotate_extrude_dxf-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest rotate extrude dxf-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output rotate extrude dxf-tests-actual
204/364 Testing: cgalpngtest_rotate_extrude_dxf-tests
204/364 Test: cgalpngtest_rotate_extrude_dxf-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/rotate_extrude_dxf-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_rotate_extrude_dxf-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: DEPRECATED: Support for reading files in rotate_extrude will be removed in future releases. Use a child import() instead.
CGAL Cache insert: rotate_extrude(file="../../dxf/open-poly (120 verts)
CGAL Cache insert: group(){rotate_extrude(file="../../dxf/o (120 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/rotate_extrude_dxf-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/rotate_extrude_dxf-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   2.12 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_rotate_extrude_dxf-tests" end time: Dec 07 22:26 CET
"cgalpngtest_rotate_extrude_dxf-tests" time elapsed: 00:00:02


cgalpngtest_null-polygons
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest null-polygons-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output null-polygons-actual
222/364 Testing: cgalpngtest_null-polygons
222/364 Test: cgalpngtest_null-polygons
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/null-polygons.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_null-polygons" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: DEPRECATED: The import_dxf() module will be removed in future releases. Use import() instead.
DEPRECATED: Support for reading files in linear_extrude will be removed in future releases. Use a child import() instead.
reduce polygons: 9 -> 1
reduce polygons: 9 -> 1
CGAL Cache insert: import(file="../../dxf/null-polygons.dxf (15 verts)
CGAL Cache insert: linear_extrude(file="../../dxf/null-poly (22 verts)
CGAL Cache insert: linear_extrude(height=1,center=false,con (22 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,20],[0,0,1, (22 verts)
CGAL Cache insert: group(){linear_extrude(height=1,center=f (44 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/null-polygons-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/null-polygons-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   2.01 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_null-polygons" end time: Dec 07 22:26 CET
"cgalpngtest_null-polygons" time elapsed: 00:00:02


cgalpngtest_import_stl-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest import stl-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output import stl-tests-actual
195/364 Testing: cgalpngtest_import_stl-tests
195/364 Test: cgalpngtest_import_stl-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/import_stl-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_import_stl-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: DEPRECATED: The import_stl() module will be removed in future releases. Use import() instead.
CGAL Cache insert: import(file="import.stl",layer="",origin (25 verts)
CGAL Cache insert: group(){import(file="import.stl",layer=" (25 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/import_stl-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/import_stl-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.61 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_import_stl-tests" end time: Dec 07 22:26 CET
"cgalpngtest_import_stl-tests" time elapsed: 00:00:01


throwntogethertest_render-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest render-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output render-tests-actual
327/364 Testing: throwntogethertest_render-tests
327/364 Test: throwntogethertest_render-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/render-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_render-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: CGAL Cache insert: render(convexity=1); (0 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=80,r1=10,r (60 verts)
CGAL Cache insert: cube(size=[20,20,150],center=true); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,-10],[0,1,0,-10],[0,0 (60 verts)
CGAL Cache insert: difference(){cube(size=[20,20,150],cente (28 verts)
CGAL Cache insert: group(){difference(){cube(size=[20,20,15 (28 verts)
CGAL Cache insert: render(convexity=2){group(){difference() (28 verts)
CGAL Cache insert: cube(size=[100,100,100],center=true); (8 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=110,r1=30, (60 verts)
CGAL Cache insert: difference(){cube(size=[100,100,100],cen (68 verts)
CGAL Cache insert: render(convexity=2){difference(){cube(si (68 verts)
XXX
Normalized CSG tree has 17 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/render-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/render-tests-actual.png
<end of output>
Test time =   3.62 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_render-tests" end time: Dec 07 22:26 CET
"throwntogethertest_render-tests" time elapsed: 00:00:03


throwntogethertest_rotate_extrude-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest rotate extrude-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output rotate extrude-tests-actual
329/364 Testing: throwntogethertest_rotate_extrude-tests
329/364 Test: throwntogethertest_rotate_extrude-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/rotate_extrude-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_rotate_extrude-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cube(size=[1,1,1],center=false); (8 verts)
ERROR: rotate_extrude() is not defined for 3D child objects!
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=10); (34 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: multmatrix([[1,0,0,20],[0,1,0,0],[0,0,1, (34 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=8); (30 verts)
CGAL Cache insert: difference(){circle($fn=0,$fa=12,$fs=1,r (60 verts)
reduce polygons: 56 -> 2
CGAL Cache insert: multmatrix([[1,0,0,20],[0,1,0,0],[0,0,1, (60 verts)
reduce polygons: 24 -> 1
CGAL Cache insert: multmatrix([[1,0,0,20],[0,1,0,0],[0,0,1, (30 verts)
Normalized CSG tree has 6 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/rotate_extrude-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/rotate_extrude-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   3.93 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_rotate_extrude-tests" end time: Dec 07 22:26 CET
"throwntogethertest_rotate_extrude-tests" time elapsed: 00:00:03


cgalpngtest_render-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest render-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output render-tests-actual
202/364 Testing: cgalpngtest_render-tests
202/364 Test: cgalpngtest_render-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/render-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_render-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=80,r1=10,r (60 verts)
CGAL Cache insert: cube(size=[20,20,150],center=true); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,-10],[0,1,0,-10],[0,0 (60 verts)
CGAL Cache insert: difference(){cube(size=[20,20,150],cente (28 verts)
CGAL Cache insert: group(){difference(){cube(size=[20,20,15 (28 verts)
CGAL Cache insert: multmatrix([[-1,-1.22465e-16,0,0],[1.224 (28 verts)
CGAL Cache insert: multmatrix([[-1.83697e-16,1,0,0],[-1,-1. (28 verts)
CGAL Cache insert: cube(size=[100,100,100],center=true); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,-50],[0,1,0,-50],[0,0 (28 verts)
CGAL Cache insert: multmatrix([[1,0,0,50],[0,1,0,-50],[0,0, (28 verts)
CGAL Cache insert: difference(){cube(size=[100,100,100],cen (56 verts)
CGAL Cache insert: render(convexity=2){group(){difference() (28 verts)
CGAL Cache insert: group(){render(convexity=2){group(){diff (28 verts)
CGAL Cache insert: multmatrix([[-1,-1.22465e-16,0,0],[1.224 (28 verts)
CGAL Cache insert: multmatrix([[-1.83697e-16,1,0,0],[-1,-1. (28 verts)
CGAL Cache insert: multmatrix([[1,0,0,-50],[0,1,0,-50],[0,0 (28 verts)
CGAL Cache insert: multmatrix([[1,0,0,50],[0,1,0,-50],[0,0, (28 verts)
CGAL Cache insert: difference(){cube(size=[100,100,100],cen (56 verts)
CGAL Cache insert: group(){difference(){cube(size=[100,100, (56 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=110,r1=30, (60 verts)
CGAL Cache insert: difference(){cube(size=[100,100,100],cen (68 verts)
CGAL Cache insert: cube(size=[10,10,10],center=false); (8 verts)
CGAL Cache insert: render(convexity=2){difference(){cube(si (68 verts)
CGAL Cache insert: multmatrix([[1,0,0,-55],[0,1,0,-55],[0,0 (8 verts)
CGAL Cache insert: difference(){render(convexity=2){differe (74 verts)
CGAL Cache insert: render(convexity=1); (0 verts)
CGAL Cache insert: group(){difference(){cube(size=[100,100, (56 verts)
CGAL Cache insert: multmatrix([[1,0,0,110],[0,1,0,0],[0,0,1 (56 verts)
CGAL Cache insert: multmatrix([[1,0,0,-110],[0,1,0,0],[0,0, (74 verts)
CGAL Cache insert: group(){render(convexity=1);render(conve (186 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/render-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/render-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   8.56 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_render-tests" end time: Dec 07 22:26 CET
"cgalpngtest_render-tests" time elapsed: 00:00:08


cgalpngtest_polygon-many-holes
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon-many-holes-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon-many-holes-actual
228/364 Testing: cgalpngtest_polygon-many-holes
228/364 Test: cgalpngtest_polygon-many-holes
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-many-holes.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon-many-holes" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 185 -> 23
CGAL Cache insert: import(file="../../dxf/polygon-many-hole (231 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygon-m (231 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon-many-holes-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon-many-holes-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   9.88 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon-many-holes" end time: Dec 07 22:26 CET
"cgalpngtest_polygon-many-holes" time elapsed: 00:00:09


cgalpngtest_polyhedron-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polyhedron-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polyhedron-tests-actual
201/364 Testing: cgalpngtest_polyhedron-tests
201/364 Test: cgalpngtest_polyhedron-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/polyhedron-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polyhedron-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output:  
CGAL::Polyhedron_incremental_builder_3<HDS>::
lookup_halfedge(): input error: facet 6 shares a halfedge from vertex 1 to vertex 4 with facet 2.
CGAL error in CGAL_Build_PolySet: CGAL ERROR: assertion violation!
Expr: check_protocoll == 0
File: /Users/kintel/code/OpenSCAD/libraries/install/include/CGAL/Polyhedron_incremental_builder_3.h
Line: 198
CGAL Cache insert: polyhedron(points=[[1,0,0],[-1,0,0],[0,1 (0 verts)
CGAL Cache insert: polyhedron(points=[[1,0,0],[-1,0,0],[0,1 (6 verts)
CGAL Cache insert: polyhedron(points=[[1,0,0],[-1,0,0],[0,1 (6 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,0],[0,0,1,0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,4],[0,1,0,0],[0,0,1,0 (6 verts)
CGAL Cache insert: cube(size=[8,3,3],center=true); (8 verts)
CGAL Cache insert: group(){polyhedron(points=[[1,0,0],[-1,0 (12 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,0],[0,0,1,2 (8 verts)
CGAL Cache insert: difference(){group(){polyhedron(points=[ (18 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,2],[0,0,1,0 (18 verts)
CGAL Cache insert: group(){group(){polyhedron(points=[[1,0, (28 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polyhedron-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polyhedron-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   2.04 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polyhedron-tests" end time: Dec 07 22:26 CET
"cgalpngtest_polyhedron-tests" time elapsed: 00:00:02


opencsgtest_render-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest render-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output render-tests-actual
263/364 Testing: opencsgtest_render-tests
263/364 Test: opencsgtest_render-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/render-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_render-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: render(convexity=1); (0 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=80,r1=10,r (60 verts)
CGAL Cache insert: cube(size=[20,20,150],center=true); (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,-10],[0,1,0,-10],[0,0 (60 verts)
CGAL Cache insert: difference(){cube(size=[20,20,150],cente (28 verts)
CGAL Cache insert: group(){difference(){cube(size=[20,20,15 (28 verts)
CGAL Cache insert: render(convexity=2){group(){difference() (28 verts)
CGAL Cache insert: cube(size=[100,100,100],center=true); (8 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=110,r1=30, (60 verts)
CGAL Cache insert: difference(){cube(size=[100,100,100],cen (68 verts)
CGAL Cache insert: render(convexity=2){difference(){cube(si (68 verts)
XXX
Normalized CSG tree has 17 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/render-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/render-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   3.21 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_render-tests" end time: Dec 07 22:26 CET
"opencsgtest_render-tests" time elapsed: 00:00:03


cgalpngtest_polygon-riser
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon-riser-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon-riser-actual
231/364 Testing: cgalpngtest_polygon-riser
231/364 Test: cgalpngtest_polygon-riser
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-riser.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon-riser" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 80 -> 3
CGAL Cache insert: import(file="../../dxf/polygon-riser.dxf (68 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygon-r (68 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon-riser-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon-riser-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   2.17 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon-riser" end time: Dec 07 22:26 CET
"cgalpngtest_polygon-riser" time elapsed: 00:00:02


cgalpngtest_polygon-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon-tests-actual
200/364 Testing: cgalpngtest_polygon-tests
200/364 Test: cgalpngtest_polygon-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/polygon-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: ERROR: Unable to convert point at index 0 to a vec2 of numbers
ERROR: Unable to convert point at index 0 to a vec2 of numbers
CGAL Cache insert: polygon(points=[[0,0],[1,0],[1,1]],paths (7 verts)
CGAL Cache insert: polygon(points=[[0,0]],paths=undef,conve (0 verts)
CGAL Cache insert: polygon(points=[[0,0],[1,1]],paths=undef (0 verts)
CGAL Cache insert: polygon(points=[[0,0],[1,1],[2,2]],paths (0 verts)
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[0,0],[1,0],[1,1],[0,1]] (8 verts)
reduce polygons: 2 -> 1
reduce polygons: 2 -> 1
CGAL Cache insert: polygon(points=[[0,0],[1,0],[1,1],[0,1]] (8 verts)
reduce polygons: 2 -> 1
reduce polygons: 3 -> 1
CGAL Cache insert: polygon(points=[[0,0],[1,0],[0.8,0.5],[1 (9 verts)
reduce polygons: 3 -> 1
reduce polygons: 6 -> 1
CGAL Cache insert: polygon(points=[[0,0],[0.5,-0.2],[1,0],[ (12 verts)
reduce polygons: 6 -> 1
reduce polygons: 4 -> 2
CGAL Cache insert: polygon(points=[[0,0],[0.5,-0.2],[1,0],[ (12 verts)
reduce polygons: 4 -> 2
CGAL Cache insert: polygon(points=[[0,0],[1,0],[1,1],[0,0]] (7 verts)
CGAL Cache insert: polygon(points=undef,paths=undef,convexi (0 verts)
CGAL Cache insert: polygon(points=[],paths=undef,convexity= (0 verts)
CGAL Cache insert: polygon(points=[[],[]],paths=undef,conve (0 verts)
CGAL Cache insert: polygon(points=[[[]]],paths=undef,convex (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,0],[0,0,1,0 (7 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,2],[0,0,1,0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,2],[0,0,1,0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,2],[0,0,1,0 (0 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-2],[0,0,1, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,0],[0,1,0,-4],[0,0,1, (8 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,-2],[0,0,1, (9 verts)
CGAL Cache insert: multmatrix([[1,0,0,-2],[0,1,0,0],[0,0,1, (12 verts)
CGAL Cache insert: multmatrix([[1,0,0,-2],[0,1,0,-2],[0,0,1 (12 verts)
CGAL Cache insert: multmatrix([[1,0,0,2],[0,1,0,-4],[0,0,1, (7 verts)
CGAL Cache insert: group(){polygon(points=undef,paths=undef (39 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   3.46 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon-tests" end time: Dec 07 22:26 CET
"cgalpngtest_polygon-tests" time elapsed: 00:00:03


opencsgtest_testcolornames
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest testcolornames-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output testcolornames-actual
270/364 Testing: opencsgtest_testcolornames
270/364 Test: opencsgtest_testcolornames
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/testcolornames.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_testcolornames" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 141 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/testcolornames-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/testcolornames-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.22 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_testcolornames" end time: Dec 07 22:26 CET
"opencsgtest_testcolornames" time elapsed: 00:00:01


opencsgtest_rotate_extrude-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest rotate extrude-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output rotate extrude-tests-actual
265/364 Testing: opencsgtest_rotate_extrude-tests
265/364 Test: opencsgtest_rotate_extrude-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/rotate_extrude-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_rotate_extrude-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cube(size=[1,1,1],center=false); (8 verts)
ERROR: rotate_extrude() is not defined for 3D child objects!
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=10); (34 verts)
reduce polygons: 28 -> 1
CGAL Cache insert: multmatrix([[1,0,0,20],[0,1,0,0],[0,0,1, (34 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=8); (30 verts)
CGAL Cache insert: difference(){circle($fn=0,$fa=12,$fs=1,r (60 verts)
reduce polygons: 56 -> 2
CGAL Cache insert: multmatrix([[1,0,0,20],[0,1,0,0],[0,0,1, (60 verts)
reduce polygons: 24 -> 1
CGAL Cache insert: multmatrix([[1,0,0,20],[0,1,0,0],[0,0,1, (30 verts)
Normalized CSG tree has 6 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/rotate_extrude-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/rotate_extrude-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   4.26 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_rotate_extrude-tests" end time: Dec 07 22:26 CET
"opencsgtest_rotate_extrude-tests" time elapsed: 00:00:04


throwntogethertest_null-polygons
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest null-polygons-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output null-polygons-actual
350/364 Testing: throwntogethertest_null-polygons
350/364 Test: throwntogethertest_null-polygons
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/null-polygons.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_null-polygons" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: DEPRECATED: The import_dxf() module will be removed in future releases. Use import() instead.
DEPRECATED: Support for reading files in linear_extrude will be removed in future releases. Use a child import() instead.
reduce polygons: 9 -> 1
CGAL Cache insert: import(file="../../dxf/null-polygons.dxf (15 verts)
Normalized CSG tree has 2 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/null-polygons-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/null-polygons-actual.png
<end of output>
Test time =   1.11 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_null-polygons" end time: Dec 07 22:26 CET
"throwntogethertest_null-polygons" time elapsed: 00:00:01


opencsgtest_null-polygons
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest null-polygons-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output null-polygons-actual
287/364 Testing: opencsgtest_null-polygons
287/364 Test: opencsgtest_null-polygons
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/null-polygons.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_null-polygons" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: DEPRECATED: The import_dxf() module will be removed in future releases. Use import() instead.
DEPRECATED: Support for reading files in linear_extrude will be removed in future releases. Use a child import() instead.
reduce polygons: 9 -> 1
CGAL Cache insert: import(file="../../dxf/null-polygons.dxf (15 verts)
Normalized CSG tree has 2 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/null-polygons-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/null-polygons-actual.png
<end of output>
Test time =   1.11 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_null-polygons" end time: Dec 07 22:26 CET
"opencsgtest_null-polygons" time elapsed: 00:00:01


throwntogethertest_minkowski2-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest minkowski2-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output minkowski2-tests-actual
324/364 Testing: throwntogethertest_minkowski2-tests
324/364 Test: throwntogethertest_minkowski2-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/minkowski2-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_minkowski2-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: CGAL Cache insert: square(size=[10,10],center=true); (8 verts)
CGAL Cache insert: square(size=[8,8],center=true); (8 verts)
CGAL Cache insert: difference(){square(size=[10,10],center= (12 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=2); (11 verts)
CGAL Cache insert: minkowski(convexity=0){difference(){squa (15 verts)
CGAL Cache insert: square(size=[10,10],center=false); (8 verts)
CGAL Cache insert: square(size=[5,5],center=false); (8 verts)
CGAL Cache insert: difference(){square(size=[10,10],center= (10 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: minkowski(convexity=0){difference(){squa (28 verts)
CGAL Cache insert: minkowski(convexity=0){square(size=[10,1 (24 verts)
Normalized CSG tree has 3 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/minkowski2-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/minkowski2-tests-actual.png
<end of output>
Test time =   1.71 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_minkowski2-tests" end time: Dec 07 22:26 CET
"throwntogethertest_minkowski2-tests" time elapsed: 00:00:01


opencsgtest_import_stl-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest import stl-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output import stl-tests-actual
255/364 Testing: opencsgtest_import_stl-tests
255/364 Test: opencsgtest_import_stl-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/import_stl-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_import_stl-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: DEPRECATED: The import_stl() module will be removed in future releases. Use import() instead.
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/import_stl-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/import_stl-tests-actual.png
<end of output>
Test time =   0.90 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_import_stl-tests" end time: Dec 07 22:26 CET
"opencsgtest_import_stl-tests" time elapsed: 00:00:00


cgalpngtest_polygon-holes-touch
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon-holes-touch-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon-holes-touch-actual
226/364 Testing: cgalpngtest_polygon-holes-touch
226/364 Test: cgalpngtest_polygon-holes-touch
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-holes-touch.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon-holes-touch" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 53 -> 2
CGAL Cache insert: import(file="../../dxf/polygon-holes-tou (55 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygon-h (55 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon-holes-touch-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon-holes-touch-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.37 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon-holes-touch" end time: Dec 07 22:26 CET
"cgalpngtest_polygon-holes-touch" time elapsed: 00:00:01


throwntogethertest_import_stl-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest import stl-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output import stl-tests-actual
319/364 Testing: throwntogethertest_import_stl-tests
319/364 Test: throwntogethertest_import_stl-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/import_stl-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_import_stl-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: DEPRECATED: The import_stl() module will be removed in future releases. Use import() instead.
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/import_stl-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/import_stl-tests-actual.png
<end of output>
Test time =   0.97 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_import_stl-tests" end time: Dec 07 22:26 CET
"throwntogethertest_import_stl-tests" time elapsed: 00:00:00


cgalpngtest_polygon-concave-hole
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon-concave-hole-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon-concave-hole-actual
223/364 Testing: cgalpngtest_polygon-concave-hole
223/364 Test: cgalpngtest_polygon-concave-hole
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-concave-hole.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon-concave-hole" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 22 -> 2
CGAL Cache insert: import(file="../../dxf/polygon-concave-h (26 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygon-c (26 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon-concave-hole-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon-concave-hole-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.27 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon-concave-hole" end time: Dec 07 22:26 CET
"cgalpngtest_polygon-concave-hole" time elapsed: 00:00:01


cgalpngtest_polygon-concave
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon-concave-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon-concave-actual
225/364 Testing: cgalpngtest_polygon-concave
225/364 Test: cgalpngtest_polygon-concave
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-concave.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon-concave" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 37 -> 1
CGAL Cache insert: import(file="../../dxf/polygon-concave.d (41 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygon-c (41 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon-concave-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon-concave-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.01 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon-concave" end time: Dec 07 22:26 CET
"cgalpngtest_polygon-concave" time elapsed: 00:00:01


throwntogethertest_linear_extrude-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest linear extrude-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output linear extrude-tests-actual
323/364 Testing: throwntogethertest_linear_extrude-tests
323/364 Test: throwntogethertest_linear_extrude-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/linear_extrude-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_linear_extrude-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: cube(size=[1,1,1],center=false); (8 verts)
ERROR: rotate_extrude() is not defined for 3D child objects!
CGAL Cache insert: square(size=[10,10],center=false); (8 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=3); (14 verts)
CGAL Cache insert: difference(){circle($fn=0,$fa=12,$fs=1,r (30 verts)
CGAL Cache insert: polygon(points=[[-5,-2.5],[5,-2.5],[0,2. (7 verts)
Normalized CSG tree has 5 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/linear_extrude-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/linear_extrude-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.52 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_linear_extrude-tests" end time: Dec 07 22:26 CET
"throwntogethertest_linear_extrude-tests" time elapsed: 00:00:01


cgalpngtest_polygons
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygons-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygons-actual
234/364 Testing: cgalpngtest_polygons
234/364 Test: cgalpngtest_polygons
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygons.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygons" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 6 -> 2
CGAL Cache insert: import(file="../../dxf/polygons.dxf",lay (14 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygons. (14 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygons-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygons-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.93 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygons" end time: Dec 07 22:26 CET
"cgalpngtest_polygons" time elapsed: 00:00:00


throwntogethertest_surface-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest surface-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output surface-tests-actual
333/364 Testing: throwntogethertest_surface-tests
333/364 Test: throwntogethertest_surface-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/surface-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_surface-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: QFSFileEngine::open: No file name specified
WARNING: Can't open DAT file `'.
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/surface-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/surface-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.32 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_surface-tests" end time: Dec 07 22:26 CET
"throwntogethertest_surface-tests" time elapsed: 00:00:01


cgalpngtest_polygon8
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon8-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon8-actual
233/364 Testing: cgalpngtest_polygon8
233/364 Test: cgalpngtest_polygon8
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon8.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon8" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: reduce polygons: 9 -> 1
CGAL Cache insert: import(file="../../dxf/polygon8.dxf",lay (15 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygon8. (15 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon8-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon8-actual.png
<end of output>
Test time =   1.12 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon8" end time: Dec 07 22:26 CET
"cgalpngtest_polygon8" time elapsed: 00:00:01


opencsgtest_minkowski2-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest minkowski2-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output minkowski2-tests-actual
260/364 Testing: opencsgtest_minkowski2-tests
260/364 Test: opencsgtest_minkowski2-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/minkowski2-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_minkowski2-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: CGAL Cache insert: square(size=[10,10],center=true); (8 verts)
CGAL Cache insert: square(size=[8,8],center=true); (8 verts)
CGAL Cache insert: difference(){square(size=[10,10],center= (12 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=2); (11 verts)
CGAL Cache insert: minkowski(convexity=0){difference(){squa (15 verts)
CGAL Cache insert: square(size=[10,10],center=false); (8 verts)
CGAL Cache insert: square(size=[5,5],center=false); (8 verts)
CGAL Cache insert: difference(){square(size=[10,10],center= (10 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: minkowski(convexity=0){difference(){squa (28 verts)
CGAL Cache insert: minkowski(convexity=0){square(size=[10,1 (24 verts)
Normalized CSG tree has 3 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/minkowski2-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/minkowski2-tests-actual.png
<end of output>
Test time =   1.64 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_minkowski2-tests" end time: Dec 07 22:26 CET
"opencsgtest_minkowski2-tests" time elapsed: 00:00:01


throwntogethertest_circle-advanced
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest circle-advanced-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output circle-advanced-actual
337/364 Testing: throwntogethertest_circle-advanced
337/364 Test: throwntogethertest_circle-advanced
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle-advanced.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_circle-advanced" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/circle-advanced-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/circle-advanced-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.94 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_circle-advanced" end time: Dec 07 22:26 CET
"throwntogethertest_circle-advanced" time elapsed: 00:00:00


cgalpngtest_polygon-concave-simple
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon-concave-simple-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon-concave-simple-actual
224/364 Testing: cgalpngtest_polygon-concave-simple
224/364 Test: cgalpngtest_polygon-concave-simple
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-concave-simple.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon-concave-simple" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: reduce polygons: 4 -> 1
CGAL Cache insert: import(file="../../dxf/polygon-concave-s (10 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygon-c (10 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon-concave-simple-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon-concave-simple-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.04 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon-concave-simple" end time: Dec 07 22:26 CET
"cgalpngtest_polygon-concave-simple" time elapsed: 00:00:01


throwntogethertest_union-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest union-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output union-tests-actual
335/364 Testing: throwntogethertest_union-tests
335/364 Test: throwntogethertest_union-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/union-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_union-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 12 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/union-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/union-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.05 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_union-tests" end time: Dec 07 22:26 CET
"throwntogethertest_union-tests" time elapsed: 00:00:01


throwntogethertest_ellipse-rot
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest ellipse-rot-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output ellipse-rot-actual
344/364 Testing: throwntogethertest_ellipse-rot
344/364 Test: throwntogethertest_ellipse-rot
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-rot.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_ellipse-rot" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/ellipse-rot-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/ellipse-rot-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.80 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_ellipse-rot" end time: Dec 07 22:26 CET
"throwntogethertest_ellipse-rot" time elapsed: 00:00:00


cgalpngtest_polygon-intersect
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon-intersect-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon-intersect-actual
227/364 Testing: cgalpngtest_polygon-intersect
227/364 Test: cgalpngtest_polygon-intersect
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-intersect.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon-intersect" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /Users/kintel/code/OpenSCAD/libraries/install/include/CGAL/Constrained_triangulation_2.h
Line: 622
CGAL Cache insert: import(file="../../dxf/polygon-intersect (0 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygon-i (0 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon-intersect-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon-intersect-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.89 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon-intersect" end time: Dec 07 22:26 CET
"cgalpngtest_polygon-intersect" time elapsed: 00:00:00


throwntogethertest_polygon-mesh
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon-mesh-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon-mesh-actual
357/364 Testing: throwntogethertest_polygon-mesh
357/364 Test: throwntogethertest_polygon-mesh
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-mesh.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon-mesh" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /Users/kintel/code/OpenSCAD/libraries/install/include/CGAL/Constrained_triangulation_2.h
Line: 622
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon-mesh-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon-mesh-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.77 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon-mesh" end time: Dec 07 22:26 CET
"throwntogethertest_polygon-mesh" time elapsed: 00:00:00


cgalpngtest_polygon-self-intersect
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon-self-intersect-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon-self-intersect-actual
232/364 Testing: cgalpngtest_polygon-self-intersect
232/364 Test: cgalpngtest_polygon-self-intersect
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-self-intersect.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon-self-intersect" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /Users/kintel/code/OpenSCAD/libraries/install/include/CGAL/Constrained_triangulation_2.h
Line: 622
CGAL Cache insert: import(file="../../dxf/polygon-self-inte (0 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygon-s (0 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon-self-intersect-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon-self-intersect-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.03 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon-self-intersect" end time: Dec 07 22:26 CET
"cgalpngtest_polygon-self-intersect" time elapsed: 00:00:01


throwntogethertest_for-nested-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest for-nested-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output for-nested-tests-actual
312/364 Testing: throwntogethertest_for-nested-tests
312/364 Test: throwntogethertest_for-nested-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/for-nested-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_for-nested-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 36 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/for-nested-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/for-nested-tests-actual.png
<end of output>
Test time =   1.03 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_for-nested-tests" end time: Dec 07 22:26 CET
"throwntogethertest_for-nested-tests" time elapsed: 00:00:01


throwntogethertest_include-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest include-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output include-tests-actual
320/364 Testing: throwntogethertest_include-tests
320/364 Test: throwntogethertest_include-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/include-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_include-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: WARNING: Can't open input file `non-file'.
Normalized CSG tree has 7 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/include-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/include-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.11 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_include-tests" end time: Dec 07 22:26 CET
"throwntogethertest_include-tests" time elapsed: 00:00:01


throwntogethertest_arc
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest arc-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output arc-actual
336/364 Testing: throwntogethertest_arc
336/364 Test: throwntogethertest_arc
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/arc.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_arc" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/arc-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/arc-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.22 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_arc" end time: Dec 07 22:26 CET
"throwntogethertest_arc" time elapsed: 00:00:01


cgalpngtest_polygon-overlap
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon-overlap-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon-overlap-actual
230/364 Testing: cgalpngtest_polygon-overlap
230/364 Test: cgalpngtest_polygon-overlap
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-overlap.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon-overlap" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: CGAL Cache insert: import(file="../../dxf/polygon-overlap.d (0 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygon-o (0 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon-overlap-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon-overlap-actual.png
<end of output>
Test time =   0.91 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon-overlap" end time: Dec 07 22:26 CET
"cgalpngtest_polygon-overlap" time elapsed: 00:00:00


throwntogethertest_polyhedron-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polyhedron-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polyhedron-tests-actual
326/364 Testing: throwntogethertest_polyhedron-tests
326/364 Test: throwntogethertest_polyhedron-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/polyhedron-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polyhedron-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: XXX
Normalized CSG tree has 9 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polyhedron-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polyhedron-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.76 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polyhedron-tests" end time: Dec 07 22:26 CET
"throwntogethertest_polyhedron-tests" time elapsed: 00:00:00


throwntogethertest_triangle-with-duplicate-vertex
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest triangle-with-duplicate-vertex-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output triangle-with-duplicate-vertex-actual
364/364 Testing: throwntogethertest_triangle-with-duplicate-vertex
364/364 Test: throwntogethertest_triangle-with-duplicate-vertex
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/triangle-with-duplicate-vertex.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_triangle-with-duplicate-vertex" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/triangle-with-duplicate-vertex-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/triangle-with-duplicate-vertex-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.80 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_triangle-with-duplicate-vertex" end time: Dec 07 22:26 CET
"throwntogethertest_triangle-with-duplicate-vertex" time elapsed: 00:00:00


throwntogethertest_rotate_extrude_dxf-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest rotate extrude dxf-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output rotate extrude dxf-tests-actual
330/364 Testing: throwntogethertest_rotate_extrude_dxf-tests
330/364 Test: throwntogethertest_rotate_extrude_dxf-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/rotate_extrude_dxf-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_rotate_extrude_dxf-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: DEPRECATED: Support for reading files in rotate_extrude will be removed in future releases. Use a child import() instead.
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/rotate_extrude_dxf-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/rotate_extrude_dxf-tests-actual.png
<end of output>
Test time =   0.80 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_rotate_extrude_dxf-tests" end time: Dec 07 22:26 CET
"throwntogethertest_rotate_extrude_dxf-tests" time elapsed: 00:00:00


throwntogethertest_polygon-holes-touch
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon-holes-touch-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon-holes-touch-actual
354/364 Testing: throwntogethertest_polygon-holes-touch
354/364 Test: throwntogethertest_polygon-holes-touch
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-holes-touch.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon-holes-touch" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon-holes-touch-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon-holes-touch-actual.png
<end of output>
Test time =   1.01 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon-holes-touch" end time: Dec 07 22:26 CET
"throwntogethertest_polygon-holes-touch" time elapsed: 00:00:01


throwntogethertest_for-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest for-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output for-tests-actual
313/364 Testing: throwntogethertest_for-tests
313/364 Test: throwntogethertest_for-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/for-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_for-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 30 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/for-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/for-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.01 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_for-tests" end time: Dec 07 22:26 CET
"throwntogethertest_for-tests" time elapsed: 00:00:01


throwntogethertest_polygon-self-intersect
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon-self-intersect-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon-self-intersect-actual
360/364 Testing: throwntogethertest_polygon-self-intersect
360/364 Test: throwntogethertest_polygon-self-intersect
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-self-intersect.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon-self-intersect" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /Users/kintel/code/OpenSCAD/libraries/install/include/CGAL/Constrained_triangulation_2.h
Line: 622
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon-self-intersect-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon-self-intersect-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.88 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon-self-intersect" end time: Dec 07 22:26 CET
"throwntogethertest_polygon-self-intersect" time elapsed: 00:00:00


throwntogethertest_cube-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest cube-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output cube-tests-actual
308/364 Testing: throwntogethertest_cube-tests
308/364 Test: throwntogethertest_cube-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/cube-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_cube-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 7 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/cube-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/cube-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.08 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_cube-tests" end time: Dec 07 22:26 CET
"throwntogethertest_cube-tests" time elapsed: 00:00:01


throwntogethertest_color-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest color-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output color-tests-actual
307/364 Testing: throwntogethertest_color-tests
307/364 Test: throwntogethertest_color-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/color-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_color-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 8 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/color-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/color-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.81 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_color-tests" end time: Dec 07 22:26 CET
"throwntogethertest_color-tests" time elapsed: 00:00:00


throwntogethertest_highlight-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest highlight-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output highlight-modifier-actual
314/364 Testing: throwntogethertest_highlight-modifier
314/364 Test: throwntogethertest_highlight-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/highlight-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_highlight-modifier" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 2 elements
Compiling highlights (1 CSG Trees)...

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/highlight-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/highlight-modifier-actual.png
<end of output>
Test time =   1.05 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_highlight-modifier" end time: Dec 07 22:26 CET
"throwntogethertest_highlight-modifier" time elapsed: 00:00:01


throwntogethertest_transform-insert
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest transform-insert-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output transform-insert-actual
363/364 Testing: throwntogethertest_transform-insert
363/364 Test: throwntogethertest_transform-insert
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/transform-insert.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_transform-insert" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/transform-insert-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/transform-insert-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.05 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_transform-insert" end time: Dec 07 22:26 CET
"throwntogethertest_transform-insert" time elapsed: 00:00:01


throwntogethertest_polygon-overlap
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon-overlap-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon-overlap-actual
358/364 Testing: throwntogethertest_polygon-overlap
358/364 Test: throwntogethertest_polygon-overlap
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-overlap.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon-overlap" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon-overlap-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon-overlap-actual.png
<end of output>
Test time =   0.84 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon-overlap" end time: Dec 07 22:26 CET
"throwntogethertest_polygon-overlap" time elapsed: 00:00:00


throwntogethertest_assign-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest assign-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output assign-tests-actual
303/364 Testing: throwntogethertest_assign-tests
303/364 Test: throwntogethertest_assign-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/assign-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_assign-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 12 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/assign-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/assign-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.71 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_assign-tests" end time: Dec 07 22:26 CET
"throwntogethertest_assign-tests" time elapsed: 00:00:00


throwntogethertest_polygon-many-holes
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon-many-holes-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon-many-holes-actual
356/364 Testing: throwntogethertest_polygon-many-holes
356/364 Test: throwntogethertest_polygon-many-holes
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-many-holes.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon-many-holes" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon-many-holes-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon-many-holes-actual.png
<end of output>
Test time =   0.81 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon-many-holes" end time: Dec 07 22:26 CET
"throwntogethertest_polygon-many-holes" time elapsed: 00:00:00


throwntogethertest_polygon-concave
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon-concave-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon-concave-actual
353/364 Testing: throwntogethertest_polygon-concave
353/364 Test: throwntogethertest_polygon-concave
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-concave.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon-concave" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon-concave-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon-concave-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.03 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon-concave" end time: Dec 07 22:26 CET
"throwntogethertest_polygon-concave" time elapsed: 00:00:01


opencsgtest_rotate_extrude_dxf-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest rotate extrude dxf-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output rotate extrude dxf-tests-actual
266/364 Testing: opencsgtest_rotate_extrude_dxf-tests
266/364 Test: opencsgtest_rotate_extrude_dxf-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/rotate_extrude_dxf-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_rotate_extrude_dxf-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: DEPRECATED: Support for reading files in rotate_extrude will be removed in future releases. Use a child import() instead.
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/rotate_extrude_dxf-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/rotate_extrude_dxf-tests-actual.png
<end of output>
Test time =   1.14 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_rotate_extrude_dxf-tests" end time: Dec 07 22:26 CET
"opencsgtest_rotate_extrude_dxf-tests" time elapsed: 00:00:01


throwntogethertest_polygon-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon-tests-actual
325/364 Testing: throwntogethertest_polygon-tests
325/364 Test: throwntogethertest_polygon-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/polygon-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: ERROR: Unable to convert point at index 0 to a vec2 of numbers
ERROR: Unable to convert point at index 0 to a vec2 of numbers
Normalized CSG tree has 12 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.00 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon-tests" end time: Dec 07 22:26 CET
"throwntogethertest_polygon-tests" time elapsed: 00:00:01


throwntogethertest_intersection-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest intersection-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output intersection-tests-actual
321/364 Testing: throwntogethertest_intersection-tests
321/364 Test: throwntogethertest_intersection-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/intersection-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_intersection-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 15 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/intersection-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/intersection-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.12 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_intersection-tests" end time: Dec 07 22:26 CET
"throwntogethertest_intersection-tests" time elapsed: 00:00:01


throwntogethertest_ellipse-reverse
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest ellipse-reverse-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output ellipse-reverse-actual
343/364 Testing: throwntogethertest_ellipse-reverse
343/364 Test: throwntogethertest_ellipse-reverse
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-reverse.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_ellipse-reverse" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/ellipse-reverse-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/ellipse-reverse-actual.png
<end of output>
Test time =   1.00 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_ellipse-reverse" end time: Dec 07 22:26 CET
"throwntogethertest_ellipse-reverse" time elapsed: 00:00:01


throwntogethertest_disable-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest disable-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output disable-modifier-actual
311/364 Testing: throwntogethertest_disable-modifier
311/364 Test: throwntogethertest_disable-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/disable-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_disable-modifier" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/disable-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/disable-modifier-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.84 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_disable-modifier" end time: Dec 07 22:26 CET
"throwntogethertest_disable-modifier" time elapsed: 00:00:00


cgalpngtest_polygon-mesh
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest polygon-mesh-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output polygon-mesh-actual
229/364 Testing: cgalpngtest_polygon-mesh
229/364 Test: cgalpngtest_polygon-mesh
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-mesh.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_polygon-mesh" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /Users/kintel/code/OpenSCAD/libraries/install/include/CGAL/Constrained_triangulation_2.h
Line: 622
CGAL Cache insert: import(file="../../dxf/polygon-mesh.dxf" (0 verts)
CGAL Cache insert: group(){import(file="../../dxf/polygon-m (0 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/polygon-mesh-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/polygon-mesh-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.84 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_polygon-mesh" end time: Dec 07 22:26 CET
"cgalpngtest_polygon-mesh" time elapsed: 00:00:00


throwntogethertest_lwpolyline-closed
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest lwpolyline-closed-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output lwpolyline-closed-actual
346/364 Testing: throwntogethertest_lwpolyline-closed
346/364 Test: throwntogethertest_lwpolyline-closed
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/lwpolyline-closed.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_lwpolyline-closed" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/lwpolyline-closed-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/lwpolyline-closed-actual.png
<end of output>
Test time =   0.95 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_lwpolyline-closed" end time: Dec 07 22:26 CET
"throwntogethertest_lwpolyline-closed" time elapsed: 00:00:00


throwntogethertest_sphere-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest sphere-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output sphere-tests-actual
331/364 Testing: throwntogethertest_sphere-tests
331/364 Test: throwntogethertest_sphere-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/sphere-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_sphere-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 10 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/sphere-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/sphere-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.85 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_sphere-tests" end time: Dec 07 22:26 CET
"throwntogethertest_sphere-tests" time elapsed: 00:00:00


throwntogethertest_2d-3d
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest 2d-3d-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output 2d-3d-actual
302/364 Testing: throwntogethertest_2d-3d
302/364 Test: throwntogethertest_2d-3d
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/2d-3d.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_2d-3d" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 2 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/2d-3d-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/2d-3d-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.87 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_2d-3d" end time: Dec 07 22:26 CET
"throwntogethertest_2d-3d" time elapsed: 00:00:00


throwntogethertest_intersection_for-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest intersection for-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output intersection for-tests-actual
322/364 Testing: throwntogethertest_intersection_for-tests
322/364 Test: throwntogethertest_intersection_for-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/intersection_for-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_intersection_for-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 4 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/intersection_for-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/intersection_for-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.86 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_intersection_for-tests" end time: Dec 07 22:26 CET
"throwntogethertest_intersection_for-tests" time elapsed: 00:00:00


throwntogethertest_ellipse
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest ellipse-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output ellipse-actual
345/364 Testing: throwntogethertest_ellipse
345/364 Test: throwntogethertest_ellipse
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_ellipse" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/ellipse-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/ellipse-actual.png
<end of output>
Test time =   1.10 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_ellipse" end time: Dec 07 22:26 CET
"throwntogethertest_ellipse" time elapsed: 00:00:01


throwntogethertest_cylinder-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest cylinder-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output cylinder-tests-actual
309/364 Testing: throwntogethertest_cylinder-tests
309/364 Test: throwntogethertest_cylinder-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/cylinder-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_cylinder-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 11 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/cylinder-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/cylinder-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.27 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_cylinder-tests" end time: Dec 07 22:26 CET
"throwntogethertest_cylinder-tests" time elapsed: 00:00:01


throwntogethertest_polygon8
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon8-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon8-actual
361/364 Testing: throwntogethertest_polygon8
361/364 Test: throwntogethertest_polygon8
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon8.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon8" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon8-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon8-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.12 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon8" end time: Dec 07 22:27 CET
"throwntogethertest_polygon8" time elapsed: 00:00:01


throwntogethertest_root-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest root-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output root-modifier-actual
328/364 Testing: throwntogethertest_root-modifier
328/364 Test: throwntogethertest_root-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/root-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_root-modifier" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/root-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/root-modifier-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.32 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_root-modifier" end time: Dec 07 22:27 CET
"throwntogethertest_root-modifier" time elapsed: 00:00:01


throwntogethertest_polygon-intersect
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon-intersect-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon-intersect-actual
355/364 Testing: throwntogethertest_polygon-intersect
355/364 Test: throwntogethertest_polygon-intersect
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-intersect.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon-intersect" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /Users/kintel/code/OpenSCAD/libraries/install/include/CGAL/Constrained_triangulation_2.h
Line: 622
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon-intersect-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon-intersect-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.07 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon-intersect" end time: Dec 07 22:27 CET
"throwntogethertest_polygon-intersect" time elapsed: 00:00:01


throwntogethertest_multiple-layers
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest multiple-layers-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output multiple-layers-actual
349/364 Testing: throwntogethertest_multiple-layers
349/364 Test: throwntogethertest_multiple-layers
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/multiple-layers.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_multiple-layers" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/multiple-layers-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/multiple-layers-actual.png
<end of output>
Test time =   0.96 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_multiple-layers" end time: Dec 07 22:27 CET
"throwntogethertest_multiple-layers" time elapsed: 00:00:00


throwntogethertest_circle-small
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest circle-small-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output circle-small-actual
339/364 Testing: throwntogethertest_circle-small
339/364 Test: throwntogethertest_circle-small
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle-small.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_circle-small" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/circle-small-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/circle-small-actual.png
<end of output>
Test time =   1.01 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_circle-small" end time: Dec 07 22:27 CET
"throwntogethertest_circle-small" time elapsed: 00:00:01


throwntogethertest_polygons
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygons-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygons-actual
362/364 Testing: throwntogethertest_polygons
362/364 Test: throwntogethertest_polygons
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygons.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygons" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygons-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygons-actual.png
<end of output>
Test time =   1.12 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygons" end time: Dec 07 22:27 CET
"throwntogethertest_polygons" time elapsed: 00:00:01


throwntogethertest_lwpolyline
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest lwpolyline-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output lwpolyline-actual
347/364 Testing: throwntogethertest_lwpolyline
347/364 Test: throwntogethertest_lwpolyline
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/lwpolyline.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_lwpolyline" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/lwpolyline-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/lwpolyline-actual.png
<end of output>
Test time =   0.92 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_lwpolyline" end time: Dec 07 22:27 CET
"throwntogethertest_lwpolyline" time elapsed: 00:00:00


throwntogethertest_import_dxf-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest import dxf-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output import dxf-tests-actual
318/364 Testing: throwntogethertest_import_dxf-tests
318/364 Test: throwntogethertest_import_dxf-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/import_dxf-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_import_dxf-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: ERROR: Unsupported file format while trying to import file ''
Normalized CSG tree has 8 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/import_dxf-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/import_dxf-tests-actual.png
<end of output>
Test time =   1.02 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_import_dxf-tests" end time: Dec 07 22:27 CET
"throwntogethertest_import_dxf-tests" time elapsed: 00:00:01


cgalpngtest_hull3-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression cgalpngtest hull3-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv cgalpngtest-output hull3-tests-actual
192/364 Testing: cgalpngtest_hull3-tests
192/364 Test: cgalpngtest_hull3-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/hull3-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"cgalpngtest_hull3-tests" start time: Dec 07 22:26 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: CGAL Cache insert: cube(size=[5,5,5],center=true); (8 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=1,r1=3,r2= (20 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=4,r1=10,r2 (60 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=5,r1=5,r2= (32 verts)
CGAL Cache insert: hull(){multmatrix([[1,0,0,0],[0,1,0,0],[ (70 verts)
CGAL Cache insert: hull(); (0 verts)
CGAL Cache insert: hull(){cylinder($fn=0,$fa=12,$fs=1,h=1,r (64 verts)
CGAL Cache insert: multmatrix([[1,0,0,25],[0,1,0,0],[0,0,1, (70 verts)
CGAL Cache insert: group(){hull();hull();hull(){cylinder($f (134 verts)

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/cgalpngtest/hull3-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/cgalpngtest-output/hull3-tests-actual.png
<end of output>
Test time =   5.12 sec
----------------------------------------------------------
Test Passed.
"cgalpngtest_hull3-tests" end time: Dec 07 22:27 CET
"cgalpngtest_hull3-tests" time elapsed: 00:00:05


throwntogethertest_polygon-concave-simple
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon-concave-simple-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon-concave-simple-actual
352/364 Testing: throwntogethertest_polygon-concave-simple
352/364 Test: throwntogethertest_polygon-concave-simple
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-concave-simple.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon-concave-simple" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon-concave-simple-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon-concave-simple-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.97 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon-concave-simple" end time: Dec 07 22:27 CET
"throwntogethertest_polygon-concave-simple" time elapsed: 00:00:00


throwntogethertest_circle-double
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest circle-double-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output circle-double-actual
338/364 Testing: throwntogethertest_circle-double
338/364 Test: throwntogethertest_circle-double
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle-double.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_circle-double" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/circle-double-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/circle-double-actual.png
<end of output>
Test time =   1.18 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_circle-double" end time: Dec 07 22:27 CET
"throwntogethertest_circle-double" time elapsed: 00:00:01


throwntogethertest_background-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest background-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output background-modifier-actual
304/364 Testing: throwntogethertest_background-modifier
304/364 Test: throwntogethertest_background-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/background-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_background-modifier" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements
Compiling background (1 CSG Trees)...

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/background-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/background-modifier-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.85 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_background-modifier" end time: Dec 07 22:27 CET
"throwntogethertest_background-modifier" time elapsed: 00:00:00


throwntogethertest_child-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest child-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output child-tests-actual
305/364 Testing: throwntogethertest_child-tests
305/364 Test: throwntogethertest_child-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/child-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_child-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 5 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/child-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/child-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.95 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_child-tests" end time: Dec 07 22:27 CET
"throwntogethertest_child-tests" time elapsed: 00:00:00


throwntogethertest_polygon-riser
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon-riser-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon-riser-actual
359/364 Testing: throwntogethertest_polygon-riser
359/364 Test: throwntogethertest_polygon-riser
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-riser.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon-riser" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon-riser-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon-riser-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.96 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon-riser" end time: Dec 07 22:27 CET
"throwntogethertest_polygon-riser" time elapsed: 00:00:00


throwntogethertest_lwpolyline2
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest lwpolyline2-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output lwpolyline2-actual
348/364 Testing: throwntogethertest_lwpolyline2
348/364 Test: throwntogethertest_lwpolyline2
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/lwpolyline2.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_lwpolyline2" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/lwpolyline2-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/lwpolyline2-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.83 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_lwpolyline2" end time: Dec 07 22:27 CET
"throwntogethertest_lwpolyline2" time elapsed: 00:00:00


throwntogethertest_square-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest square-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output square-tests-actual
332/364 Testing: throwntogethertest_square-tests
332/364 Test: throwntogethertest_square-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/square-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_square-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 8 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/square-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/square-tests-actual.png
<end of output>
Test time =   0.79 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_square-tests" end time: Dec 07 22:27 CET
"throwntogethertest_square-tests" time elapsed: 00:00:00


throwntogethertest_ellipse-arc
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest ellipse-arc-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output ellipse-arc-actual
342/364 Testing: throwntogethertest_ellipse-arc
342/364 Test: throwntogethertest_ellipse-arc
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-arc.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_ellipse-arc" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/ellipse-arc-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/ellipse-arc-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.89 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_ellipse-arc" end time: Dec 07 22:27 CET
"throwntogethertest_ellipse-arc" time elapsed: 00:00:00


throwntogethertest_ellipse-arc-rot
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest ellipse-arc-rot-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output ellipse-arc-rot-actual
341/364 Testing: throwntogethertest_ellipse-arc-rot
341/364 Test: throwntogethertest_ellipse-arc-rot
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-arc-rot.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_ellipse-arc-rot" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/ellipse-arc-rot-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/ellipse-arc-rot-actual.png
<end of output>
Test time =   1.21 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_ellipse-arc-rot" end time: Dec 07 22:27 CET
"throwntogethertest_ellipse-arc-rot" time elapsed: 00:00:01


throwntogethertest_transform-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest transform-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output transform-tests-actual
334/364 Testing: throwntogethertest_transform-tests
334/364 Test: throwntogethertest_transform-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/transform-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_transform-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 7 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/transform-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/transform-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.32 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_transform-tests" end time: Dec 07 22:27 CET
"throwntogethertest_transform-tests" time elapsed: 00:00:01


throwntogethertest_ifelse-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest ifelse-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output ifelse-tests-actual
317/364 Testing: throwntogethertest_ifelse-tests
317/364 Test: throwntogethertest_ifelse-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/ifelse-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_ifelse-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: WARNING: Ignoring unknown variable 'ILLEGAL'.
Normalized CSG tree has 11 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/ifelse-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/ifelse-tests-actual.png
<end of output>
Test time =   1.12 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_ifelse-tests" end time: Dec 07 22:27 CET
"throwntogethertest_ifelse-tests" time elapsed: 00:00:01


throwntogethertest_circle-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest circle-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output circle-tests-actual
306/364 Testing: throwntogethertest_circle-tests
306/364 Test: throwntogethertest_circle-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/circle-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_circle-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 10 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/circle-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/circle-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.20 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_circle-tests" end time: Dec 07 22:27 CET
"throwntogethertest_circle-tests" time elapsed: 00:00:01


opencsgtest_arc
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest arc-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output arc-actual
273/364 Testing: opencsgtest_arc
273/364 Test: opencsgtest_arc
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/arc.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_arc" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/arc-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/arc-actual.png
<end of output>
Test time =   0.91 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_arc" end time: Dec 07 22:27 CET
"opencsgtest_arc" time elapsed: 00:00:00


opencsgtest_ellipse
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest ellipse-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output ellipse-actual
282/364 Testing: opencsgtest_ellipse
282/364 Test: opencsgtest_ellipse
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_ellipse" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/ellipse-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/ellipse-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.95 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ellipse" end time: Dec 07 22:27 CET
"opencsgtest_ellipse" time elapsed: 00:00:00


throwntogethertest_polygon-concave-hole
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest polygon-concave-hole-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output polygon-concave-hole-actual
351/364 Testing: throwntogethertest_polygon-concave-hole
351/364 Test: throwntogethertest_polygon-concave-hole
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-concave-hole.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_polygon-concave-hole" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/polygon-concave-hole-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/polygon-concave-hole-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.02 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_polygon-concave-hole" end time: Dec 07 22:27 CET
"throwntogethertest_polygon-concave-hole" time elapsed: 00:00:01


opencsgtest_linear_extrude-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest linear extrude-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output linear extrude-tests-actual
259/364 Testing: opencsgtest_linear_extrude-tests
259/364 Test: opencsgtest_linear_extrude-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/linear_extrude-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_linear_extrude-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: CGAL Cache insert: cube(size=[1,1,1],center=false); (8 verts)
ERROR: rotate_extrude() is not defined for 3D child objects!
CGAL Cache insert: square(size=[10,10],center=false); (8 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=5); (20 verts)
CGAL Cache insert: circle($fn=0,$fa=12,$fs=1,r=3); (14 verts)
CGAL Cache insert: difference(){circle($fn=0,$fa=12,$fs=1,r (30 verts)
CGAL Cache insert: polygon(points=[[-5,-2.5],[5,-2.5],[0,2. (7 verts)
Normalized CSG tree has 5 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/linear_extrude-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/linear_extrude-tests-actual.png
<end of output>
Test time =   1.64 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_linear_extrude-tests" end time: Dec 07 22:27 CET
"opencsgtest_linear_extrude-tests" time elapsed: 00:00:01


opencsgtest_circle
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest circle-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output circle-actual
277/364 Testing: opencsgtest_circle
277/364 Test: opencsgtest_circle
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_circle" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/circle-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/circle-actual.png
<end of output>
Test time =   1.24 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_circle" end time: Dec 07 22:27 CET
"opencsgtest_circle" time elapsed: 00:00:01


opencsgtest_polygon-holes-touch
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon-holes-touch-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon-holes-touch-actual
291/364 Testing: opencsgtest_polygon-holes-touch
291/364 Test: opencsgtest_polygon-holes-touch
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-holes-touch.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon-holes-touch" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon-holes-touch-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon-holes-touch-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.23 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-holes-touch" end time: Dec 07 22:27 CET
"opencsgtest_polygon-holes-touch" time elapsed: 00:00:01


opencsgtest_polygon-many-holes
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon-many-holes-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon-many-holes-actual
293/364 Testing: opencsgtest_polygon-many-holes
293/364 Test: opencsgtest_polygon-many-holes
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-many-holes.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon-many-holes" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon-many-holes-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon-many-holes-actual.png
<end of output>
Test time =   1.22 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-many-holes" end time: Dec 07 22:27 CET
"opencsgtest_polygon-many-holes" time elapsed: 00:00:01


opencsgtest_polygon-concave-hole
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon-concave-hole-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon-concave-hole-actual
288/364 Testing: opencsgtest_polygon-concave-hole
288/364 Test: opencsgtest_polygon-concave-hole
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-concave-hole.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon-concave-hole" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon-concave-hole-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon-concave-hole-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.41 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-concave-hole" end time: Dec 07 22:27 CET
"opencsgtest_polygon-concave-hole" time elapsed: 00:00:01


opencsgtest_hull3-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest hull3-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output hull3-tests-actual
252/364 Testing: opencsgtest_hull3-tests
252/364 Test: opencsgtest_hull3-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/hull3-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_hull3-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: CGAL Cache insert: hull(); (0 verts)
CGAL Cache insert: cube(size=[5,5,5],center=true); (8 verts)
CGAL Cache insert: hull(){cylinder($fn=0,$fa=12,$fs=1,h=1,r (64 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=1,r1=3,r2= (20 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=4,r1=10,r2 (60 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=5,r1=5,r2= (32 verts)
CGAL Cache insert: hull(){multmatrix([[1,0,0,0],[0,1,0,0],[ (70 verts)
Normalized CSG tree has 2 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/hull3-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/hull3-tests-actual.png
<end of output>
Test time =   4.77 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_hull3-tests" end time: Dec 07 22:27 CET
"opencsgtest_hull3-tests" time elapsed: 00:00:04


opencsgtest_polygon-concave
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon-concave-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon-concave-actual
290/364 Testing: opencsgtest_polygon-concave
290/364 Test: opencsgtest_polygon-concave
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-concave.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon-concave" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon-concave-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon-concave-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.31 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-concave" end time: Dec 07 22:27 CET
"opencsgtest_polygon-concave" time elapsed: 00:00:01


opencsgtest_polygons
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygons-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygons-actual
299/364 Testing: opencsgtest_polygons
299/364 Test: opencsgtest_polygons
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygons.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygons" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygons-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygons-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.52 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygons" end time: Dec 07 22:27 CET
"opencsgtest_polygons" time elapsed: 00:00:01


throwntogethertest_hull3-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest hull3-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output hull3-tests-actual
316/364 Testing: throwntogethertest_hull3-tests
316/364 Test: throwntogethertest_hull3-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/hull3-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_hull3-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: CGAL Cache insert: hull(); (0 verts)
CGAL Cache insert: cube(size=[5,5,5],center=true); (8 verts)
CGAL Cache insert: hull(){cylinder($fn=0,$fa=12,$fs=1,h=1,r (64 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=1,r1=3,r2= (20 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=4,r1=10,r2 (60 verts)
CGAL Cache insert: cylinder($fn=0,$fa=12,$fs=1,h=5,r1=5,r2= (32 verts)
CGAL Cache insert: hull(){multmatrix([[1,0,0,0],[0,1,0,0],[ (70 verts)
Normalized CSG tree has 2 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/hull3-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/hull3-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   4.81 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_hull3-tests" end time: Dec 07 22:27 CET
"throwntogethertest_hull3-tests" time elapsed: 00:00:04


opencsgtest_lwpolyline
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest lwpolyline-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output lwpolyline-actual
284/364 Testing: opencsgtest_lwpolyline
284/364 Test: opencsgtest_lwpolyline
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/lwpolyline.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_lwpolyline" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/lwpolyline-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/lwpolyline-actual.png
<end of output>
Test time =   1.26 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_lwpolyline" end time: Dec 07 22:27 CET
"opencsgtest_lwpolyline" time elapsed: 00:00:01


opencsgtest_polygon-overlap
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon-overlap-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon-overlap-actual
295/364 Testing: opencsgtest_polygon-overlap
295/364 Test: opencsgtest_polygon-overlap
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-overlap.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon-overlap" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon-overlap-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon-overlap-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.25 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-overlap" end time: Dec 07 22:27 CET
"opencsgtest_polygon-overlap" time elapsed: 00:00:01


opencsgtest_polygon-mesh
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon-mesh-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon-mesh-actual
294/364 Testing: opencsgtest_polygon-mesh
294/364 Test: opencsgtest_polygon-mesh
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-mesh.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon-mesh" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /Users/kintel/code/OpenSCAD/libraries/install/include/CGAL/Constrained_triangulation_2.h
Line: 622
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon-mesh-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon-mesh-actual.png
<end of output>
Test time =   1.05 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-mesh" end time: Dec 07 22:27 CET
"opencsgtest_polygon-mesh" time elapsed: 00:00:01


opencsgtest_highlight-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest highlight-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output highlight-modifier-actual
250/364 Testing: opencsgtest_highlight-modifier
250/364 Test: opencsgtest_highlight-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/highlight-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_highlight-modifier" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 2 elements
Compiling highlights (1 CSG Trees)...

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/highlight-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/highlight-modifier-actual.png
<end of output>
Test time =   0.91 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_highlight-modifier" end time: Dec 07 22:27 CET
"opencsgtest_highlight-modifier" time elapsed: 00:00:00


opencsgtest_polygon-self-intersect
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon-self-intersect-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon-self-intersect-actual
297/364 Testing: opencsgtest_polygon-self-intersect
297/364 Test: opencsgtest_polygon-self-intersect
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-self-intersect.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon-self-intersect" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /Users/kintel/code/OpenSCAD/libraries/install/include/CGAL/Constrained_triangulation_2.h
Line: 622
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon-self-intersect-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon-self-intersect-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.91 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-self-intersect" end time: Dec 07 22:27 CET
"opencsgtest_polygon-self-intersect" time elapsed: 00:00:00


opencsgtest_surface-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest surface-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output surface-tests-actual
269/364 Testing: opencsgtest_surface-tests
269/364 Test: opencsgtest_surface-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/surface-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_surface-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: QFSFileEngine::open: No file name specified
WARNING: Can't open DAT file `'.
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/surface-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/surface-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.02 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_surface-tests" end time: Dec 07 22:27 CET
"opencsgtest_surface-tests" time elapsed: 00:00:01


opencsgtest_ellipse-reverse
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest ellipse-reverse-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output ellipse-reverse-actual
280/364 Testing: opencsgtest_ellipse-reverse
280/364 Test: opencsgtest_ellipse-reverse
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-reverse.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_ellipse-reverse" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/ellipse-reverse-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/ellipse-reverse-actual.png
<end of output>
Test time =   0.96 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ellipse-reverse" end time: Dec 07 22:27 CET
"opencsgtest_ellipse-reverse" time elapsed: 00:00:00


opencsgtest_2d-3d
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest 2d-3d-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output 2d-3d-actual
237/364 Testing: opencsgtest_2d-3d
237/364 Test: opencsgtest_2d-3d
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/2d-3d.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_2d-3d" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 2 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/2d-3d-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/2d-3d-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.16 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_2d-3d" end time: Dec 07 22:27 CET
"opencsgtest_2d-3d" time elapsed: 00:00:01


opencsgtest_ellipse-rot
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest ellipse-rot-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output ellipse-rot-actual
281/364 Testing: opencsgtest_ellipse-rot
281/364 Test: opencsgtest_ellipse-rot
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-rot.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_ellipse-rot" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/ellipse-rot-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/ellipse-rot-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.16 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ellipse-rot" end time: Dec 07 22:27 CET
"opencsgtest_ellipse-rot" time elapsed: 00:00:01


opencsgtest_circle-advanced
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest circle-advanced-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output circle-advanced-actual
274/364 Testing: opencsgtest_circle-advanced
274/364 Test: opencsgtest_circle-advanced
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle-advanced.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_circle-advanced" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/circle-advanced-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/circle-advanced-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.91 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_circle-advanced" end time: Dec 07 22:27 CET
"opencsgtest_circle-advanced" time elapsed: 00:00:00


opencsgtest_multiple-layers
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest multiple-layers-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output multiple-layers-actual
286/364 Testing: opencsgtest_multiple-layers
286/364 Test: opencsgtest_multiple-layers
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/multiple-layers.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_multiple-layers" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/multiple-layers-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/multiple-layers-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.85 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_multiple-layers" end time: Dec 07 22:27 CET
"opencsgtest_multiple-layers" time elapsed: 00:00:00


opencsgtest_ellipse-arc-rot
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest ellipse-arc-rot-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output ellipse-arc-rot-actual
278/364 Testing: opencsgtest_ellipse-arc-rot
278/364 Test: opencsgtest_ellipse-arc-rot
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-arc-rot.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_ellipse-arc-rot" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/ellipse-arc-rot-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/ellipse-arc-rot-actual.png
<end of output>
Test time =   0.94 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ellipse-arc-rot" end time: Dec 07 22:27 CET
"opencsgtest_ellipse-arc-rot" time elapsed: 00:00:00


opencsgtest_polyhedron-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polyhedron-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polyhedron-tests-actual
262/364 Testing: opencsgtest_polyhedron-tests
262/364 Test: opencsgtest_polyhedron-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/polyhedron-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polyhedron-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: XXX
Normalized CSG tree has 9 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polyhedron-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polyhedron-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.89 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polyhedron-tests" end time: Dec 07 22:27 CET
"opencsgtest_polyhedron-tests" time elapsed: 00:00:00


opencsgtest_polygon-riser
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon-riser-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon-riser-actual
296/364 Testing: opencsgtest_polygon-riser
296/364 Test: opencsgtest_polygon-riser
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-riser.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon-riser" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon-riser-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon-riser-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.13 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-riser" end time: Dec 07 22:27 CET
"opencsgtest_polygon-riser" time elapsed: 00:00:01


opencsgtest_transform-insert
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest transform-insert-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output transform-insert-actual
300/364 Testing: opencsgtest_transform-insert
300/364 Test: opencsgtest_transform-insert
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/transform-insert.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_transform-insert" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/transform-insert-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/transform-insert-actual.png
<end of output>
Test time =   0.90 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_transform-insert" end time: Dec 07 22:27 CET
"opencsgtest_transform-insert" time elapsed: 00:00:00


opencsgtest_polygon8
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon8-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon8-actual
298/364 Testing: opencsgtest_polygon8
298/364 Test: opencsgtest_polygon8
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon8.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon8" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon8-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon8-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.90 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon8" end time: Dec 07 22:27 CET
"opencsgtest_polygon8" time elapsed: 00:00:00


opencsgtest_triangle-with-duplicate-vertex
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest triangle-with-duplicate-vertex-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output triangle-with-duplicate-vertex-actual
301/364 Testing: opencsgtest_triangle-with-duplicate-vertex
301/364 Test: opencsgtest_triangle-with-duplicate-vertex
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/triangle-with-duplicate-vertex.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_triangle-with-duplicate-vertex" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/triangle-with-duplicate-vertex-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/triangle-with-duplicate-vertex-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.06 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_triangle-with-duplicate-vertex" end time: Dec 07 22:27 CET
"opencsgtest_triangle-with-duplicate-vertex" time elapsed: 00:00:01


opencsgtest_lwpolyline-closed
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest lwpolyline-closed-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output lwpolyline-closed-actual
283/364 Testing: opencsgtest_lwpolyline-closed
283/364 Test: opencsgtest_lwpolyline-closed
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/lwpolyline-closed.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_lwpolyline-closed" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/lwpolyline-closed-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/lwpolyline-closed-actual.png
<end of output>
Test time =   1.07 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_lwpolyline-closed" end time: Dec 07 22:27 CET
"opencsgtest_lwpolyline-closed" time elapsed: 00:00:01


opencsgtest_polygon-intersect
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon-intersect-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon-intersect-actual
292/364 Testing: opencsgtest_polygon-intersect
292/364 Test: opencsgtest_polygon-intersect
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-intersect.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon-intersect" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output:  sorry, this triangulation does not deal with
 intersecting constraints
CGAL error in dxf_tesselate(): CGAL ERROR: assertion violation!
Expr: false
File: /Users/kintel/code/OpenSCAD/libraries/install/include/CGAL/Constrained_triangulation_2.h
Line: 622
Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon-intersect-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon-intersect-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.83 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-intersect" end time: Dec 07 22:27 CET
"opencsgtest_polygon-intersect" time elapsed: 00:00:00


opencsgtest_lwpolyline2
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest lwpolyline2-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output lwpolyline2-actual
285/364 Testing: opencsgtest_lwpolyline2
285/364 Test: opencsgtest_lwpolyline2
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/lwpolyline2.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_lwpolyline2" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/lwpolyline2-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/lwpolyline2-actual.png
<end of output>
Test time =   0.95 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_lwpolyline2" end time: Dec 07 22:27 CET
"opencsgtest_lwpolyline2" time elapsed: 00:00:00


opencsgtest_sphere-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest sphere-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output sphere-tests-actual
267/364 Testing: opencsgtest_sphere-tests
267/364 Test: opencsgtest_sphere-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/sphere-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_sphere-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 10 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/sphere-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/sphere-tests-actual.png
<end of output>
Test time =   1.01 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_sphere-tests" end time: Dec 07 22:27 CET
"opencsgtest_sphere-tests" time elapsed: 00:00:01


opencsgtest_ellipse-arc
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest ellipse-arc-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output ellipse-arc-actual
279/364 Testing: opencsgtest_ellipse-arc
279/364 Test: opencsgtest_ellipse-arc
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/ellipse-arc.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_ellipse-arc" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/ellipse-arc-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/ellipse-arc-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.76 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ellipse-arc" end time: Dec 07 22:27 CET
"opencsgtest_ellipse-arc" time elapsed: 00:00:00


opencsgtest_circle-small
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest circle-small-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output circle-small-actual
276/364 Testing: opencsgtest_circle-small
276/364 Test: opencsgtest_circle-small
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle-small.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_circle-small" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/circle-small-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/circle-small-actual.png
<end of output>
Test time =   0.77 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_circle-small" end time: Dec 07 22:27 CET
"opencsgtest_circle-small" time elapsed: 00:00:00


opencsgtest_highlight-and-background-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest highlight-and-background-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output highlight-and-background-modifier-actual
249/364 Testing: opencsgtest_highlight-and-background-modifier
249/364 Test: opencsgtest_highlight-and-background-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/highlight-and-background-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_highlight-and-background-modifier" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 2 elements
Compiling highlights (2 CSG Trees)...
Compiling background (2 CSG Trees)...

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/highlight-and-background-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/highlight-and-background-modifier-actual.png
<end of output>
Test time =   0.81 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_highlight-and-background-modifier" end time: Dec 07 22:27 CET
"opencsgtest_highlight-and-background-modifier" time elapsed: 00:00:00


opencsgtest_polygon-concave-simple
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon-concave-simple-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon-concave-simple-actual
289/364 Testing: opencsgtest_polygon-concave-simple
289/364 Test: opencsgtest_polygon-concave-simple
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/polygon-concave-simple.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon-concave-simple" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon-concave-simple-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon-concave-simple-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.79 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-concave-simple" end time: Dec 07 22:27 CET
"opencsgtest_polygon-concave-simple" time elapsed: 00:00:00


opencsgtest_circle-double
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest circle-double-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output circle-double-actual
275/364 Testing: opencsgtest_circle-double
275/364 Test: opencsgtest_circle-double
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/dxf/circle-double.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_circle-double" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/circle-double-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/circle-double-actual.png
<end of output>
Test time =   1.00 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_circle-double" end time: Dec 07 22:27 CET
"opencsgtest_circle-double" time elapsed: 00:00:00


opencsgtest_background-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest background-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output background-modifier-actual
239/364 Testing: opencsgtest_background-modifier
239/364 Test: opencsgtest_background-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/background-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_background-modifier" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 1 elements
Compiling background (1 CSG Trees)...

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/background-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/background-modifier-actual.png
<end of output>
Test time =   1.01 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_background-modifier" end time: Dec 07 22:27 CET
"opencsgtest_background-modifier" time elapsed: 00:00:01


opencsgtest_ifelse-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest ifelse-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output ifelse-tests-actual
253/364 Testing: opencsgtest_ifelse-tests
253/364 Test: opencsgtest_ifelse-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/ifelse-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_ifelse-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: WARNING: Ignoring unknown variable 'ILLEGAL'.
Normalized CSG tree has 11 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/ifelse-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/ifelse-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.21 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_ifelse-tests" end time: Dec 07 22:27 CET
"opencsgtest_ifelse-tests" time elapsed: 00:00:01


opencsgtest_cube-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest cube-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output cube-tests-actual
243/364 Testing: opencsgtest_cube-tests
243/364 Test: opencsgtest_cube-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/cube-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_cube-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 7 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/cube-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/cube-tests-actual.png
<end of output>
Test time =   1.03 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_cube-tests" end time: Dec 07 22:27 CET
"opencsgtest_cube-tests" time elapsed: 00:00:01


opencsgtest_for-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest for-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output for-tests-actual
248/364 Testing: opencsgtest_for-tests
248/364 Test: opencsgtest_for-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/for-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_for-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 30 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/for-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/for-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.22 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_for-tests" end time: Dec 07 22:27 CET
"opencsgtest_for-tests" time elapsed: 00:00:01


opencsgtest_transform-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest transform-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output transform-tests-actual
271/364 Testing: opencsgtest_transform-tests
271/364 Test: opencsgtest_transform-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/transform-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_transform-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 7 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/transform-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/transform-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.98 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_transform-tests" end time: Dec 07 22:27 CET
"opencsgtest_transform-tests" time elapsed: 00:00:00


opencsgtest_intersection-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest intersection-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output intersection-tests-actual
257/364 Testing: opencsgtest_intersection-tests
257/364 Test: opencsgtest_intersection-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/intersection-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_intersection-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 15 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/intersection-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/intersection-tests-actual.png
<end of output>
Test time =   1.18 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_intersection-tests" end time: Dec 07 22:27 CET
"opencsgtest_intersection-tests" time elapsed: 00:00:01


opencsgtest_disable-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest disable-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output disable-modifier-actual
246/364 Testing: opencsgtest_disable-modifier
246/364 Test: opencsgtest_disable-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/disable-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_disable-modifier" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/disable-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/disable-modifier-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.07 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_disable-modifier" end time: Dec 07 22:27 CET
"opencsgtest_disable-modifier" time elapsed: 00:00:01


opencsgtest_color-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest color-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output color-tests-actual
242/364 Testing: opencsgtest_color-tests
242/364 Test: opencsgtest_color-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/color-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_color-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 8 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/color-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/color-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.94 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_color-tests" end time: Dec 07 22:27 CET
"opencsgtest_color-tests" time elapsed: 00:00:00


opencsgtest_child-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest child-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output child-tests-actual
240/364 Testing: opencsgtest_child-tests
240/364 Test: opencsgtest_child-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/child-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_child-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 5 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/child-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/child-tests-actual.png
<end of output>
Test time =   1.00 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_child-tests" end time: Dec 07 22:27 CET
"opencsgtest_child-tests" time elapsed: 00:00:00


throwntogethertest_difference-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression throwntogethertest difference-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv throwntogethertest-output difference-tests-actual
310/364 Testing: throwntogethertest_difference-tests
310/364 Test: throwntogethertest_difference-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/difference-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"throwntogethertest_difference-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 11 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/throwntogethertest/difference-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/throwntogethertest-output/difference-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.16 sec
----------------------------------------------------------
Test Passed.
"throwntogethertest_difference-tests" end time: Dec 07 22:27 CET
"throwntogethertest_difference-tests" time elapsed: 00:00:01


opencsgtest_intersection_for-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest intersection for-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output intersection for-tests-actual
258/364 Testing: opencsgtest_intersection_for-tests
258/364 Test: opencsgtest_intersection_for-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/intersection_for-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_intersection_for-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 4 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/intersection_for-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/intersection_for-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.04 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_intersection_for-tests" end time: Dec 07 22:27 CET
"opencsgtest_intersection_for-tests" time elapsed: 00:00:01


opencsgtest_square-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest square-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output square-tests-actual
268/364 Testing: opencsgtest_square-tests
268/364 Test: opencsgtest_square-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/square-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_square-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 8 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/square-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/square-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.15 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_square-tests" end time: Dec 07 22:27 CET
"opencsgtest_square-tests" time elapsed: 00:00:01


opencsgtest_circle-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest circle-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output circle-tests-actual
241/364 Testing: opencsgtest_circle-tests
241/364 Test: opencsgtest_circle-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/circle-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_circle-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 10 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/circle-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/circle-tests-actual.png
<end of output>
Test time =   0.82 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_circle-tests" end time: Dec 07 22:27 CET
"opencsgtest_circle-tests" time elapsed: 00:00:00


opencsgtest_include-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest include-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output include-tests-actual
256/364 Testing: opencsgtest_include-tests
256/364 Test: opencsgtest_include-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/include-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_include-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: WARNING: Can't open input file `non-file'.
Normalized CSG tree has 7 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/include-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/include-tests-actual.png
<end of output>
Test time =   0.81 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_include-tests" end time: Dec 07 22:27 CET
"opencsgtest_include-tests" time elapsed: 00:00:00


opencsgtest_for-nested-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest for-nested-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output for-nested-tests-actual
247/364 Testing: opencsgtest_for-nested-tests
247/364 Test: opencsgtest_for-nested-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/for-nested-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_for-nested-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 36 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/for-nested-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/for-nested-tests-actual.png
<end of output>
Test time =   1.02 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_for-nested-tests" end time: Dec 07 22:27 CET
"opencsgtest_for-nested-tests" time elapsed: 00:00:01


opencsgtest_import_dxf-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest import dxf-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output import dxf-tests-actual
254/364 Testing: opencsgtest_import_dxf-tests
254/364 Test: opencsgtest_import_dxf-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/import_dxf-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_import_dxf-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: ERROR: Unsupported file format while trying to import file ''
Normalized CSG tree has 8 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/import_dxf-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/import_dxf-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.94 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_import_dxf-tests" end time: Dec 07 22:27 CET
"opencsgtest_import_dxf-tests" time elapsed: 00:00:00


opencsgtest_union-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest union-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output union-tests-actual
272/364 Testing: opencsgtest_union-tests
272/364 Test: opencsgtest_union-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/union-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_union-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 12 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/union-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/union-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.86 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_union-tests" end time: Dec 07 22:27 CET
"opencsgtest_union-tests" time elapsed: 00:00:00


opencsgtest_cylinder-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest cylinder-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output cylinder-tests-actual
244/364 Testing: opencsgtest_cylinder-tests
244/364 Test: opencsgtest_cylinder-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/cylinder-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_cylinder-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 11 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/cylinder-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/cylinder-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.86 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_cylinder-tests" end time: Dec 07 22:27 CET
"opencsgtest_cylinder-tests" time elapsed: 00:00:00


opencsgtest_assign-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest assign-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output assign-tests-actual
238/364 Testing: opencsgtest_assign-tests
238/364 Test: opencsgtest_assign-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/assign-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_assign-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Imagemagick return 0 output: 0

Error output: Normalized CSG tree has 12 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/assign-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/assign-tests-actual.png
<end of output>
Test time =   1.21 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_assign-tests" end time: Dec 07 22:27 CET
"opencsgtest_assign-tests" time elapsed: 00:00:01


opencsgtest_polygon-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest polygon-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output polygon-tests-actual
261/364 Testing: opencsgtest_polygon-tests
261/364 Test: opencsgtest_polygon-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/polygon-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_polygon-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: ERROR: Unable to convert point at index 0 to a vec2 of numbers
ERROR: Unable to convert point at index 0 to a vec2 of numbers
Normalized CSG tree has 12 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/polygon-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/polygon-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   1.08 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_polygon-tests" end time: Dec 07 22:27 CET
"opencsgtest_polygon-tests" time elapsed: 00:00:01


opencsgtest_root-modifier
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest root-modifier-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output root-modifier-actual
264/364 Testing: opencsgtest_root-modifier
264/364 Test: opencsgtest_root-modifier
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/root-modifier.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_root-modifier" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 1 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/root-modifier-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/root-modifier-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.90 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_root-modifier" end time: Dec 07 22:27 CET
"opencsgtest_root-modifier" time elapsed: 00:00:00


opencsgtest_difference-tests
Expected image Actual image
OpenSCAD mac 64-bit nvidia-geforce-gt cdiv tests regression opencsgtest difference-tests-expected OpenSCAD mac 64-bit nvidia-geforce-gt cdiv opencsgtest-output difference-tests-actual
245/364 Testing: opencsgtest_difference-tests
245/364 Test: opencsgtest_difference-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "png" "/Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/difference-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"opencsgtest_difference-tests" start time: Dec 07 22:27 CET
Output:
----------------------------------------------------------
Error output: Normalized CSG tree has 11 elements

ImageMagick image comparison: /opt/local/bin/convert -alpha Off -compose difference -composite -threshold 10% -morphology Erode Square -format %[fx:w*h*mean] info:
expected image: /Users/kintel/code/OpenSCAD/openscad/tests/regression/opencsgtest/difference-tests-expected.png

 actual image:  /Users/kintel/code/OpenSCAD/openscad/tests/opencsgtest-output/difference-tests-actual.png
Imagemagick return 0 output: 0

<end of output>
Test time =   0.96 sec
----------------------------------------------------------
Test Passed.
"opencsgtest_difference-tests" end time: Dec 07 22:27 CET
"opencsgtest_difference-tests" time elapsed: 00:00:00




Text tests

dumptest_hull2-tests
65/364 Testing: dumptest_hull2-tests
65/364 Test: dumptest_hull2-tests
Command: "/usr/bin/python" "/Users/kintel/code/OpenSCAD/openscad/tests/test_cmdline_tool.py" "--comparator=" "-c" "/opt/local/bin/convert" "-s" "txt" "/Users/kintel/code/OpenSCAD/openscad/tests/dumptest" "/Users/kintel/code/OpenSCAD/openscad/tests/../testdata/scad/features/hull2-tests.scad"
Directory: /Users/kintel/code/OpenSCAD/openscad/tests
"dumptest_hull2-tests" start time: Dec 07 22:25 CET
Output:
----------------------------------------------------------
diff text compare: 
 expected textfile:  /Users/kintel/code/OpenSCAD/openscad/tests/regression/dumptest/hull2-tests-expected.txt
 actual textfile:  /Users/kintel/code/OpenSCAD/openscad/tests/dumptest-output/hull2-tests-actual.txt
<end of output>
Test time =   6.61 sec
----------------------------------------------------------
Test Passed.
"dumptest_hull2-tests" end time: Dec 07 22:25 CET
"dumptest_hull2-tests" time elapsed: 00:00:06