1// =============================================================================
2// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
4//
5//  This file is distributed under the same license as the Scilab package.
6// =============================================================================
7// <-- TEST WITH GRAPHIC -->
8// Unit test for plot2d()
9x=(0.1:0.1:2*%pi)';
10// Error messages with type, size or number of input arguments
11errmsg=msprintf(_("%s: Wrong number of mandatory input arguments. At least %d expected.\n"),"plot2d",1);
12assert_checkerror("plot2d( logflag=""nn"", style=[-1,-2,3], rect=[0,-2,2*%pi,2], axesflag=1)", errmsg);
13errmsg=msprintf(_("%s: Wrong size for input arguments: Incompatible sizes.\n"),"plot2d");
14assert_checkerror("plot2d(1, sin(x), logflag=""nn"", style=[-1,-2,3], rect=[0,-2,2*%pi,2], axesflag=1)",errmsg);
15errmsg=[msprintf(_("Function not defined for given argument type(s),\n"));msprintf(_("  check arguments or define function %s for overloading.\n"), "%c_plot2d")];
16assert_checkerror("plot2d(x, ""s"", logflag=""nn"", style=[-1,-2,3], rect=[0,-2,2*%pi,2], axesflag=1)",errmsg);
17// Error messages with log mode
18errmsg=msprintf(_("%s: Bounds on y axis must be strictly positive to use logarithmic mode.\n"),"plot2d");
19assert_checkerror("plot2d(x, [sin(x)], logflag=""nl"", style=[-1,-2,3], rect=[0,-2,2*%pi,2], axesflag=1)", errmsg);
20errmsg=msprintf(_("%s: Bounds on x axis must be strictly positive to use logarithmic mode.\n"),"plot2d");
21assert_checkerror("plot2d(x, [sin(x)], logflag=""ln"", style=[-1,-2,3], rect=[0,-2,2*%pi,2], axesflag=1)", errmsg);
22errmsg=msprintf(_("%s: Bounds on x axis must be strictly positive to use logarithmic mode.\n"),"plot2d");
23assert_checkerror("plot2d(x, [sin(x)], logflag=""ll"", style=[-1,-2,3], rect=[0,-2,2*%pi,2], axesflag=1)", errmsg);
24// Error message with rect
25errmsg=msprintf(_("%s: Impossible status min > max in x or y rect data.\n"),"plot2d");
26assert_checkerror("plot2d(x, sin(x), logflag=""nn"", style=[-1,-2,3], rect=[2,0,2*%pi,-2], axesflag=1)",errmsg);
27// Check plot2(x, sin(x))
28close
29x=(0.1:0.1:2*%pi)';
30plot2d(x, sin(x));
31f=gcf();
32a=gca();
33c=a.children(1); //compound
34p=c.children(1); //polyline
35// Check figure
36assert_checkequal(f.auto_resize, "on");
37assert_checkequal(f.viewport, [0,0]);
38assert_checkequal(f.figure_name, gettext("Graphic window number %d"));
39assert_checkequal(f.figure_id, 0);
40assert_checkequal(f.pixel_drawing_mode, "copy");
41assert_checkequal(f.anti_aliasing, "off");
42assert_checkequal(f.immediate_drawing, "on");
43assert_checkequal(f.background, -2);
44assert_checkequal(f.visible, "on");
45assert_checkequal(f.rotation_style, "unary");
46assert_checkequal(f.event_handler, "");
47assert_checkequal(f.event_handler_enable, "off");
48assert_checkequal(f.user_data, []);
49assert_checkequal(f.tag, "");
50// Check axes
51assert_checkequal(a.visible, "on");
52assert_checkequal(a.axes_visible, ["on" "on" "on"]);
53assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
54assert_checkequal(a.grid, [-1 -1]);
55assert_checkequal(a.grid_position, "background");
56assert_checkequal(a.x_location, "bottom");
57assert_checkequal(a.y_location, "left");
58assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
59assert_checkequal(a.box, "off");
60assert_checkequal(a.filled, "on");
61assert_checkequal(a.sub_ticks, [0, 1]);
62assert_checkequal(a.font_style, 6);
63assert_checkequal(a.font_size, 1);
64assert_checkequal(a.font_color, -1);
65assert_checkequal(a.fractional_font, "off");
66assert_checkequal(a.isoview, "off");
67assert_checkequal(a.cube_scaling, "off");
68assert_checkequal(a.view, "2d");
69assert_checkequal(a.rotation_angles, [0, 270]);
70assert_checkequal(a.log_flags, "nnn");
71assert_checkequal(a.tight_limits, ["off", "off", "off"]);
72assert_checktrue(a.data_bounds - [1,-0.9999233;63,0.9995736] < 1d-7);
73assert_checkequal(a.zoom_box, []);
74assert_checkequal(a.margins, [0.125, 0.125, 0.125, 0.125]);
75assert_checkequal(a.axes_bounds, [0, 0, 1, 1]);
76assert_checkequal(a.auto_clear, "off");
77assert_checkequal(a.auto_scale, "on");
78assert_checkequal(a.hidden_axis_color, 4);
79assert_checkequal(a.hiddencolor, 4);
80assert_checkequal(a.line_mode, "on");
81assert_checkequal(a.line_style, 1);
82assert_checkequal(a.thickness, 1);
83assert_checkequal(a.mark_mode, "off");
84assert_checkequal(a.mark_style, 0);
85assert_checkequal(a.mark_size_unit, "tabulated");
86assert_checkequal(a.mark_size, 0);
87assert_checkequal(a.mark_foreground, -1);
88assert_checkequal(a.mark_background, -2);
89assert_checkequal(a.foreground, -1);
90assert_checkequal(a.background, -2);
91assert_checkequal(a.arc_drawing_method, "lines");
92assert_checkequal(a.clip_state, "clipgrf");
93assert_checkequal(a.clip_box, []);
94assert_checkequal(a.user_data, []);
95// Check compound
96assert_checkequal(c.parent.type, "Axes");
97assert_checkequal(c.children(:).type, "Polyline");
98assert_checkequal(c.visible, "on");
99assert_checkequal(c.user_data, []);
100// Check polyline
101DefaultData=(0.1:0.1:2*%pi)';
102assert_checkequal(p.parent.type, "Compound");
103assert_checkequal(p.children, []);
104assert_checkequal(p.visible, "on");
105assert_checkequal(p.data, [DefaultData, sin(DefaultData)]);
106assert_checkequal(p.closed, "off");
107assert_checkequal(p.line_mode, "on");
108assert_checkequal(p.fill_mode, "off");
109assert_checkequal(p.line_style, 1);
110assert_checkequal(p.thickness, 1);
111assert_checkequal(p.arrow_size_factor, 1);
112assert_checkequal(p.polyline_style, 1);
113assert_checkequal(p.foreground, 1);
114assert_checkequal(p.background, -2);
115assert_checkequal(p.interp_color_vector, []);
116assert_checkequal(p.interp_color_mode, "off");
117assert_checkequal(p.mark_mode, "off");
118assert_checkequal(p.mark_style, 0);
119assert_checkequal(p.mark_size_unit, "tabulated");
120assert_checkequal(p.mark_size, 0);
121assert_checkequal(p.mark_foreground, -1);
122assert_checkequal(p.mark_background, -2);
123assert_checkequal(p.x_shift, []);
124assert_checkequal(p.y_shift, []);
125assert_checkequal(p.z_shift, []);
126assert_checkequal(p.bar_width, 0);
127assert_checkequal(p.clip_state, "clipgrf");
128assert_checkequal(p.clip_box, []);
129assert_checkequal(p.user_data, []);
130// Check plot2d(x, sin(x), loglag="nl")
131close
132x=(0.1:0.1:2*%pi)';
133plot2d(x, sin(x), logflag="nl");
134f=gcf();
135a=gca();
136c=a.children(1); //compound
137p=c.children(1); //polyline
138// Check figure
139assert_checkequal(f.auto_resize, "on");
140assert_checkequal(f.viewport, [0,0]);
141assert_checkequal(f.figure_name, gettext("Graphic window number %d"));
142assert_checkequal(f.figure_id, 0);
143assert_checkequal(f.pixel_drawing_mode, "copy");
144assert_checkequal(f.anti_aliasing, "off");
145assert_checkequal(f.immediate_drawing, "on");
146assert_checkequal(f.background, -2);
147assert_checkequal(f.visible, "on");
148assert_checkequal(f.rotation_style, "unary");
149assert_checkequal(f.event_handler, "");
150assert_checkequal(f.event_handler_enable, "off");
151assert_checkequal(f.user_data, []);
152assert_checkequal(f.tag, "");
153// Check axes
154assert_checkequal(a.visible, "on");
155assert_checkequal(a.axes_visible, ["on" "on" "on"]);
156assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
157assert_checkequal(a.grid, [-1 -1]);
158assert_checkequal(a.grid_position, "background");
159assert_checkequal(a.x_location, "bottom");
160assert_checkequal(a.y_location, "left");
161assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
162assert_checkequal(a.box, "off");
163assert_checkequal(a.filled, "on");
164assert_checkequal(a.sub_ticks, [0, 4]);
165assert_checkequal(a.font_style, 6);
166assert_checkequal(a.font_size, 1);
167assert_checkequal(a.font_color, -1);
168assert_checkequal(a.fractional_font, "off");
169assert_checkequal(a.isoview, "off");
170assert_checkequal(a.cube_scaling, "off");
171assert_checkequal(a.view, "2d");
172assert_checkequal(a.rotation_angles, [0, 270]);
173assert_checkequal(a.log_flags, "nln");
174assert_checkequal(a.tight_limits, ["off", "off", "off"]);
175assert_checktrue(a.data_bounds - [0.1, 0.0415807; 6.2, 0.9995736] < 1d-7);
176assert_checkequal(a.zoom_box, []);
177assert_checkequal(a.margins, [0.125, 0.125, 0.125, 0.125]);
178assert_checkequal(a.axes_bounds, [0, 0, 1, 1]);
179assert_checkequal(a.auto_clear, "off");
180assert_checkequal(a.auto_scale, "on");
181assert_checkequal(a.hidden_axis_color, 4);
182assert_checkequal(a.hiddencolor, 4);
183assert_checkequal(a.line_mode, "on");
184assert_checkequal(a.line_style, 1);
185assert_checkequal(a.thickness, 1);
186assert_checkequal(a.mark_mode, "off");
187assert_checkequal(a.mark_style, 0);
188assert_checkequal(a.mark_size_unit, "tabulated");
189assert_checkequal(a.mark_size, 0);
190assert_checkequal(a.mark_foreground, -1);
191assert_checkequal(a.mark_background, -2);
192assert_checkequal(a.foreground, -1);
193assert_checkequal(a.background, -2);
194assert_checkequal(a.arc_drawing_method, "lines");
195assert_checkequal(a.clip_state, "clipgrf");
196assert_checkequal(a.clip_box, []);
197assert_checkequal(a.user_data, []);
198// Check compound
199assert_checkequal(c.parent.type, "Axes");
200assert_checkequal(c.children(:).type, "Polyline");
201assert_checkequal(c.visible, "on");
202assert_checkequal(c.user_data, []);
203// Check polyline
204DefaultData=(0.1:0.1:2*%pi)';
205assert_checkequal(p.parent.type, "Compound");
206assert_checkequal(p.children, []);
207assert_checkequal(p.visible, "on");
208assert_checkequal(p.data, [DefaultData, sin(DefaultData)]);
209assert_checkequal(p.closed, "off");
210assert_checkequal(p.line_mode, "on");
211assert_checkequal(p.fill_mode, "off");
212assert_checkequal(p.line_style, 1);
213assert_checkequal(p.thickness, 1);
214assert_checkequal(p.arrow_size_factor, 1);
215assert_checkequal(p.polyline_style, 1);
216assert_checkequal(p.foreground, 1);
217assert_checkequal(p.background, -2);
218assert_checkequal(p.interp_color_vector, []);
219assert_checkequal(p.interp_color_mode, "off");
220assert_checkequal(p.mark_mode, "off");
221assert_checkequal(p.mark_style, 0);
222assert_checkequal(p.mark_size_unit, "tabulated");
223assert_checkequal(p.mark_size, 0);
224assert_checkequal(p.mark_foreground, -1);
225assert_checkequal(p.mark_background, -2);
226assert_checkequal(p.x_shift, []);
227assert_checkequal(p.y_shift, []);
228assert_checkequal(p.z_shift, []);
229assert_checkequal(p.bar_width, 0);
230assert_checkequal(p.clip_state, "clipgrf");
231assert_checkequal(p.clip_box, []);
232assert_checkequal(p.user_data, []);
233// Check plot2d(x, sin(x), logflag="ln")
234close
235x=(0.1:0.1:2*%pi)';
236plot2d(x, sin(x), logflag="ln");
237f=gcf();
238a=gca();
239c=a.children(1); //compound
240p=c.children(1); //polyline
241// Check sub_ticks
242assert_checkequal(a.sub_ticks, [3, 1]);
243// Check data_bounds
244assert_checktrue(a.data_bounds - [0.1, - 0.9999233 ; 6.2, 0.9995736] < 1d-7);
245// Check logflags
246assert_checkequal(a.log_flags, "lnn");
247// Check data
248assert_checkequal(p.data, [DefaultData, sin(DefaultData)]);
249// Check plot2d(x, sin(x), logflag="ll")
250close
251x=(0.1:0.1:2*%pi)';
252plot2d(x, sin(x), logflag="ll");
253f=gcf();
254a=gca();
255c=a.children(1); //compound
256p=c.children(1); //polyline
257// Check sub_ticks
258assert_checkequal(a.sub_ticks, [3, 4]);
259// Check data_bounds
260assert_checktrue(a.data_bounds - [0.1, 0.0415807 ; 6.2, 0.9995736] < 1d-7);
261// Check logflags
262assert_checkequal(a.log_flags, "lln");
263// Check data
264assert_checkequal(p.data, [DefaultData, sin(DefaultData)]);
265// Check style=[-1,-2,-3,-4]
266close
267x=(0.1:0.1:2*%pi)';
268plot2d(x, [sin(x),sin(2*x), sin(3*x), sin(4*x)], style=[-1,-2,-3,-4]);
269f=gcf();
270a=gca();
271c=a.children(1); //compound
272p1=c.children(1); //polyline 1
273p2=c.children(2); //polyline 2
274p3=c.children(3); //polyline 3
275p4=c.children(4); //polyline 4
276// Check polyline 1
277DefaultData=(0.1:0.1:2*%pi)';
278assert_checkequal(p1.parent.type, "Compound");
279assert_checkequal(p1.children, []);
280assert_checkequal(p1.visible, "on");
281assert_checkequal(p1.data, [DefaultData, sin(4*DefaultData)]);
282assert_checkequal(p1.closed, "off");
283assert_checkequal(p1.line_mode, "off");
284assert_checkequal(p1.fill_mode, "off");
285assert_checkequal(p1.line_style, 1);
286assert_checkequal(p1.thickness, 1);
287assert_checkequal(p1.arrow_size_factor, 1);
288assert_checkequal(p1.polyline_style, 1);
289assert_checkequal(p1.foreground, -1);
290assert_checkequal(p1.background, -2);
291assert_checkequal(p1.interp_color_vector, []);
292assert_checkequal(p1.interp_color_mode, "off");
293assert_checkequal(p1.mark_mode, "on");
294assert_checkequal(p1.mark_style, 4);
295assert_checkequal(p1.mark_size_unit, "tabulated");
296assert_checkequal(p1.mark_size, 0);
297assert_checkequal(p1.mark_foreground, -1);
298assert_checkequal(p1.mark_background, -2);
299assert_checkequal(p1.x_shift, []);
300assert_checkequal(p1.y_shift, []);
301assert_checkequal(p1.z_shift, []);
302assert_checkequal(p1.bar_width, 0);
303assert_checkequal(p1.clip_state, "clipgrf");
304assert_checkequal(p1.clip_box, []);
305assert_checkequal(p1.user_data, []);
306// Check polyline 2;
307assert_checkequal(p2.parent.type, "Compound");
308assert_checkequal(p2.children, []);
309assert_checkequal(p2.visible, "on");
310assert_checkequal(p2.data, [DefaultData, sin(3*DefaultData)]);
311assert_checkequal(p2.closed, "off");
312assert_checkequal(p2.line_mode, "off");
313assert_checkequal(p2.fill_mode, "off");
314assert_checkequal(p2.line_style, 1);
315assert_checkequal(p2.thickness, 1);
316assert_checkequal(p2.arrow_size_factor, 1);
317assert_checkequal(p2.polyline_style, 1);
318assert_checkequal(p2.foreground, -1);
319assert_checkequal(p2.background, -2);
320assert_checkequal(p2.interp_color_vector, []);
321assert_checkequal(p2.interp_color_mode, "off");
322assert_checkequal(p2.mark_mode, "on");
323assert_checkequal(p2.mark_style, 3);
324assert_checkequal(p2.mark_size_unit, "tabulated");
325assert_checkequal(p2.mark_size, 0);
326assert_checkequal(p2.mark_foreground, -1);
327assert_checkequal(p2.mark_background, -2);
328assert_checkequal(p2.x_shift, []);
329assert_checkequal(p2.y_shift, []);
330assert_checkequal(p2.z_shift, []);
331assert_checkequal(p2.bar_width, 0);
332assert_checkequal(p2.clip_state, "clipgrf");
333assert_checkequal(p2.clip_box, []);
334assert_checkequal(p2.user_data, []);
335// Check polyline 3;
336assert_checkequal(p3.parent.type, "Compound");
337assert_checkequal(p3.children, []);
338assert_checkequal(p3.visible, "on");
339assert_checkequal(p3.data, [DefaultData, sin(2*DefaultData)]);
340assert_checkequal(p3.closed, "off");
341assert_checkequal(p3.line_mode, "off");
342assert_checkequal(p3.fill_mode, "off");
343assert_checkequal(p3.line_style, 1);
344assert_checkequal(p3.thickness, 1);
345assert_checkequal(p3.arrow_size_factor, 1);
346assert_checkequal(p3.polyline_style, 1);
347assert_checkequal(p3.foreground, -1);
348assert_checkequal(p3.background, -2);
349assert_checkequal(p3.interp_color_vector, []);
350assert_checkequal(p3.interp_color_mode, "off");
351assert_checkequal(p3.mark_mode, "on");
352assert_checkequal(p3.mark_style, 2);
353assert_checkequal(p3.mark_size_unit, "tabulated");
354assert_checkequal(p3.mark_size, 0);
355assert_checkequal(p3.mark_foreground, -1);
356assert_checkequal(p3.mark_background, -2);
357assert_checkequal(p3.x_shift, []);
358assert_checkequal(p3.y_shift, []);
359assert_checkequal(p3.z_shift, []);
360assert_checkequal(p3.bar_width, 0);
361assert_checkequal(p3.clip_state, "clipgrf");
362assert_checkequal(p3.clip_box, []);
363assert_checkequal(p3.user_data, []);
364// Check polyline 4;
365assert_checkequal(p4.parent.type, "Compound");
366assert_checkequal(p4.children, []);
367assert_checkequal(p4.visible, "on");
368assert_checkequal(p4.data, [DefaultData, sin(DefaultData)]);
369assert_checkequal(p4.closed, "off");
370assert_checkequal(p4.line_mode, "off");
371assert_checkequal(p4.fill_mode, "off");
372assert_checkequal(p4.line_style, 1);
373assert_checkequal(p4.thickness, 1);
374assert_checkequal(p4.arrow_size_factor, 1);
375assert_checkequal(p4.polyline_style, 1);
376assert_checkequal(p4.foreground, -1);
377assert_checkequal(p4.background, -2);
378assert_checkequal(p4.interp_color_vector, []);
379assert_checkequal(p4.interp_color_mode, "off");
380assert_checkequal(p4.mark_mode, "on");
381assert_checkequal(p4.mark_style, 1);
382assert_checkequal(p4.mark_size_unit, "tabulated");
383assert_checkequal(p4.mark_size, 0);
384assert_checkequal(p4.mark_foreground, -1);
385assert_checkequal(p4.mark_background, -2);
386assert_checkequal(p4.x_shift, []);
387assert_checkequal(p4.y_shift, []);
388assert_checkequal(p4.z_shift, []);
389assert_checkequal(p4.bar_width, 0);
390assert_checkequal(p4.clip_state, "clipgrf");
391assert_checkequal(p4.clip_box, []);
392assert_checkequal(p4.user_data, []);
393// Check rect=[0,-2,2*%pi,2]
394close
395x=(0.1:0.1:2*%pi)';
396plot2d(x, sin(x), rect=[0,-2,2*%pi,2]);
397f=gcf();
398a=gca();
399c=a.children(1); //compound
400p=c.children(1); //polyline
401// Check axes
402assert_checkequal(a.visible, "on");
403assert_checkequal(a.axes_visible, ["on" "on" "on"]);
404assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
405assert_checkequal(a.grid, [-1 -1]);
406assert_checkequal(a.grid_position, "background");
407assert_checkequal(a.x_location, "bottom");
408assert_checkequal(a.y_location, "left");
409assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
410assert_checkequal(a.box, "off");
411assert_checkequal(a.filled, "on");
412assert_checkequal(a.sub_ticks, [0, 4]);
413assert_checkequal(a.font_style, 6);
414assert_checkequal(a.font_size, 1);
415assert_checkequal(a.font_color, -1);
416assert_checkequal(a.fractional_font, "off");
417assert_checkequal(a.isoview, "off");
418assert_checkequal(a.cube_scaling, "off");
419assert_checkequal(a.view, "2d");
420assert_checkequal(a.rotation_angles, [0, 270]);
421assert_checkequal(a.log_flags, "nnn");
422assert_checkequal(a.tight_limits, ["on", "on", "on"]);
423assert_checkequal(a.data_bounds, [0, -2; 2*%pi, 2]);
424assert_checkequal(a.zoom_box, []);
425assert_checkequal(a.margins, [0.125, 0.125, 0.125, 0.125]);
426assert_checkequal(a.axes_bounds, [0, 0, 1, 1]);
427assert_checkequal(a.auto_clear, "off");
428assert_checkequal(a.auto_scale, "on");
429assert_checkequal(a.hidden_axis_color, 4);
430assert_checkequal(a.hiddencolor, 4);
431assert_checkequal(a.line_mode, "on");
432assert_checkequal(a.line_style, 1);
433assert_checkequal(a.thickness, 1);
434assert_checkequal(a.mark_mode, "off");
435assert_checkequal(a.mark_style, 0);
436assert_checkequal(a.mark_size_unit, "tabulated");
437assert_checkequal(a.mark_size, 0);
438assert_checkequal(a.mark_foreground, -1);
439assert_checkequal(a.mark_background, -2);
440assert_checkequal(a.foreground, -1);
441assert_checkequal(a.background, -2);
442assert_checkequal(a.arc_drawing_method, "lines");
443assert_checkequal(a.clip_state, "clipgrf");
444assert_checkequal(a.clip_box, []);
445assert_checkequal(a.user_data, []);
446// Check compound
447assert_checkequal(c.parent.type, "Axes");
448assert_checkequal(c.children(:).type, "Polyline");
449assert_checkequal(c.visible, "on");
450assert_checkequal(c.user_data, []);
451// Check polyline
452DefaultData=(0.1:0.1:2*%pi)';
453assert_checkequal(p.parent.type, "Compound");
454assert_checkequal(p.children, []);
455assert_checkequal(p.visible, "on");
456assert_checkequal(p.data, [DefaultData, sin(DefaultData)]);
457assert_checkequal(p.closed, "off");
458assert_checkequal(p.line_mode, "on");
459assert_checkequal(p.fill_mode, "off");
460assert_checkequal(p.line_style, 1);
461assert_checkequal(p.thickness, 1);
462assert_checkequal(p.arrow_size_factor, 1);
463assert_checkequal(p.polyline_style, 1);
464assert_checkequal(p.foreground, 1);
465assert_checkequal(p.background, -2);
466assert_checkequal(p.interp_color_vector, []);
467assert_checkequal(p.interp_color_mode, "off");
468assert_checkequal(p.mark_mode, "off");
469assert_checkequal(p.mark_style, 0);
470assert_checkequal(p.mark_size_unit, "tabulated");
471assert_checkequal(p.mark_size, 0);
472assert_checkequal(p.mark_foreground, -1);
473assert_checkequal(p.mark_background, -2);
474assert_checkequal(p.x_shift, []);
475assert_checkequal(p.y_shift, []);
476assert_checkequal(p.z_shift, []);
477assert_checkequal(p.bar_width, 0);
478assert_checkequal(p.clip_state, "clipgrf");
479assert_checkequal(p.clip_box, []);
480assert_checkequal(p.user_data, []);
481// Check axesflag=1
482close
483x=(0.1:0.1:2*%pi)';
484plot2d(x, sin(x), axesflag=1);
485f=gcf();
486a=gca();
487c=a.children(1); //compound
488p=c.children(1); //polyline
489// Check axes
490assert_checkequal(a.visible, "on");
491assert_checkequal(a.axes_visible, ["on" "on" "on"]);
492assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
493assert_checkequal(a.grid, [-1 -1]);
494assert_checkequal(a.grid_position, "background");
495assert_checkequal(a.x_location, "bottom");
496assert_checkequal(a.y_location, "left");
497assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
498assert_checkequal(a.box, "on");
499assert_checkequal(a.filled, "on");
500assert_checkequal(a.sub_ticks, [0, 1]);
501assert_checkequal(a.font_style, 6);
502assert_checkequal(a.font_size, 1);
503assert_checkequal(a.font_color, -1);
504assert_checkequal(a.fractional_font, "off");
505assert_checkequal(a.isoview, "off");
506assert_checkequal(a.cube_scaling, "off");
507assert_checkequal(a.view, "2d");
508assert_checkequal(a.rotation_angles, [0, 270]);
509assert_checkequal(a.log_flags, "nnn");
510assert_checkequal(a.tight_limits, ["off", "off", "off"]);
511assert_checktrue(a.data_bounds - [0.1, 0.0415807; 6.2, 0.9995736] < 1d-7);
512assert_checkequal(a.zoom_box, []);
513assert_checkequal(a.margins, [0.125, 0.125, 0.125, 0.125]);
514assert_checkequal(a.axes_bounds, [0, 0, 1, 1]);
515assert_checkequal(a.auto_clear, "off");
516assert_checkequal(a.auto_scale, "on");
517assert_checkequal(a.hidden_axis_color, 4);
518assert_checkequal(a.hiddencolor, 4);
519assert_checkequal(a.line_mode, "on");
520assert_checkequal(a.line_style, 1);
521assert_checkequal(a.thickness, 1);
522assert_checkequal(a.mark_mode, "off");
523assert_checkequal(a.mark_style, 0);
524assert_checkequal(a.mark_size_unit, "tabulated");
525assert_checkequal(a.mark_size, 0);
526assert_checkequal(a.mark_foreground, -1);
527assert_checkequal(a.mark_background, -2);
528assert_checkequal(a.foreground, -1);
529assert_checkequal(a.background, -2);
530assert_checkequal(a.arc_drawing_method, "lines");
531assert_checkequal(a.clip_state, "clipgrf");
532assert_checkequal(a.clip_box, []);
533assert_checkequal(a.user_data, []);
534// Check axesflag=2
535close
536x=(0.1:0.1:2*%pi)';
537plot2d(x, sin(x), axesflag=2);
538f=gcf();
539a=gca();
540c=a.children(1); //compound
541p=c.children(1); //polyline
542// Check axes
543assert_checkequal(a.visible, "on");
544assert_checkequal(a.axes_visible, ["off" "off" "off"]);
545assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
546assert_checkequal(a.grid, [-1 -1]);
547assert_checkequal(a.grid_position, "background");
548assert_checkequal(a.x_location, "bottom");
549assert_checkequal(a.y_location, "left");
550assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
551assert_checkequal(a.box, "on");
552assert_checkequal(a.filled, "on");
553assert_checkequal(a.sub_ticks, [1, 1]);
554assert_checkequal(a.font_style, 6);
555assert_checkequal(a.font_size, 1);
556assert_checkequal(a.font_color, -1);
557assert_checkequal(a.fractional_font, "off");
558assert_checkequal(a.isoview, "off");
559assert_checkequal(a.cube_scaling, "off");
560assert_checkequal(a.view, "2d");
561assert_checkequal(a.rotation_angles, [0, 270]);
562assert_checkequal(a.log_flags, "nnn");
563assert_checkequal(a.tight_limits, ["off", "off", "off"]);
564assert_checktrue(a.data_bounds - [0.1, 0.0415807; 6.2, 0.9995736] < 1d-7);
565assert_checkequal(a.zoom_box, []);
566assert_checkequal(a.margins, [0.125, 0.125, 0.125, 0.125]);
567assert_checkequal(a.axes_bounds, [0, 0, 1, 1]);
568assert_checkequal(a.auto_clear, "off");
569assert_checkequal(a.auto_scale, "on");
570assert_checkequal(a.hidden_axis_color, 4);
571assert_checkequal(a.hiddencolor, 4);
572assert_checkequal(a.line_mode, "on");
573assert_checkequal(a.line_style, 1);
574assert_checkequal(a.thickness, 1);
575assert_checkequal(a.mark_mode, "off");
576assert_checkequal(a.mark_style, 0);
577assert_checkequal(a.mark_size_unit, "tabulated");
578assert_checkequal(a.mark_size, 0);
579assert_checkequal(a.mark_foreground, -1);
580assert_checkequal(a.mark_background, -2);
581assert_checkequal(a.foreground, -1);
582assert_checkequal(a.background, -2);
583assert_checkequal(a.arc_drawing_method, "lines");
584assert_checkequal(a.clip_state, "clipgrf");
585assert_checkequal(a.clip_box, []);
586assert_checkequal(a.user_data, []);
587// Check axesflag=3
588close
589x=(0.1:0.1:2*%pi)';
590plot2d(x, sin(x), axesflag=3);
591f=gcf();
592a=gca();
593c=a.children(1); //compound
594p=c.children(1); //polyline
595// Check axes
596assert_checkequal(a.visible, "on");
597assert_checkequal(a.axes_visible, ["on" "on" "on"]);
598assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
599assert_checkequal(a.grid, [-1 -1]);
600assert_checkequal(a.grid_position, "background");
601assert_checkequal(a.x_location, "bottom");
602assert_checkequal(a.y_location, "right");
603assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
604assert_checkequal(a.box, "off");
605assert_checkequal(a.filled, "on");
606assert_checkequal(a.sub_ticks, [0, 1]);
607assert_checkequal(a.font_style, 6);
608assert_checkequal(a.font_size, 1);
609assert_checkequal(a.font_color, -1);
610assert_checkequal(a.fractional_font, "off");
611assert_checkequal(a.isoview, "off");
612assert_checkequal(a.cube_scaling, "off");
613assert_checkequal(a.view, "2d");
614assert_checkequal(a.rotation_angles, [0, 270]);
615assert_checkequal(a.log_flags, "nnn");
616assert_checkequal(a.tight_limits, ["off", "off", "off"]);
617assert_checktrue(a.data_bounds - [0.1, 0.0415807; 6.2, 0.9995736] < 1d-7);
618assert_checkequal(a.zoom_box, []);
619assert_checkequal(a.margins, [0.125, 0.125, 0.125, 0.125]);
620assert_checkequal(a.axes_bounds, [0, 0, 1, 1]);
621assert_checkequal(a.auto_clear, "off");
622assert_checkequal(a.auto_scale, "on");
623assert_checkequal(a.hidden_axis_color, 4);
624assert_checkequal(a.hiddencolor, 4);
625assert_checkequal(a.line_mode, "on");
626assert_checkequal(a.line_style, 1);
627assert_checkequal(a.thickness, 1);
628assert_checkequal(a.mark_mode, "off");
629assert_checkequal(a.mark_style, 0);
630assert_checkequal(a.mark_size_unit, "tabulated");
631assert_checkequal(a.mark_size, 0);
632assert_checkequal(a.mark_foreground, -1);
633assert_checkequal(a.mark_background, -2);
634assert_checkequal(a.foreground, -1);
635assert_checkequal(a.background, -2);
636assert_checkequal(a.arc_drawing_method, "lines");
637assert_checkequal(a.clip_state, "clipgrf");
638assert_checkequal(a.clip_box, []);
639assert_checkequal(a.user_data, []);
640// Check axesflag=4
641close
642x=(0.1:0.1:2*%pi)';
643plot2d(x, sin(x), axesflag=4);
644f=gcf();
645a=gca();
646c=a.children(1); //compound
647p=c.children(1); //polyline
648// Check axes
649assert_checkequal(a.visible, "on");
650assert_checkequal(a.axes_visible, ["on" "on" "on"]);
651assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
652assert_checkequal(a.grid, [-1 -1]);
653assert_checkequal(a.grid_position, "background");
654assert_checkequal(a.x_location, "middle");
655assert_checkequal(a.y_location, "middle");
656assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
657assert_checkequal(a.box, "off");
658assert_checkequal(a.filled, "on");
659assert_checkequal(a.sub_ticks, [0, 1]);
660assert_checkequal(a.font_style, 6);
661assert_checkequal(a.font_size, 1);
662assert_checkequal(a.font_color, -1);
663assert_checkequal(a.fractional_font, "off");
664assert_checkequal(a.isoview, "off");
665assert_checkequal(a.cube_scaling, "off");
666assert_checkequal(a.view, "2d");
667assert_checkequal(a.rotation_angles, [0, 270]);
668assert_checkequal(a.log_flags, "nnn");
669assert_checkequal(a.tight_limits, ["off", "off", "off"]);
670assert_checktrue(a.data_bounds - [0.1, 0.0415807; 6.2, 0.9995736] < 1d-7);
671assert_checkequal(a.zoom_box, []);
672assert_checkequal(a.margins, [0.125, 0.125, 0.125, 0.125]);
673assert_checkequal(a.axes_bounds, [0, 0, 1, 1]);
674assert_checkequal(a.auto_clear, "off");
675assert_checkequal(a.auto_scale, "on");
676assert_checkequal(a.hidden_axis_color, 4);
677assert_checkequal(a.hiddencolor, 4);
678assert_checkequal(a.line_mode, "on");
679assert_checkequal(a.line_style, 1);
680assert_checkequal(a.thickness, 1);
681assert_checkequal(a.mark_mode, "off");
682assert_checkequal(a.mark_style, 0);
683assert_checkequal(a.mark_size_unit, "tabulated");
684assert_checkequal(a.mark_size, 0);
685assert_checkequal(a.mark_foreground, -1);
686assert_checkequal(a.mark_background, -2);
687assert_checkequal(a.foreground, -1);
688assert_checkequal(a.background, -2);
689assert_checkequal(a.arc_drawing_method, "lines");
690assert_checkequal(a.clip_state, "clipgrf");
691assert_checkequal(a.clip_box, []);
692assert_checkequal(a.user_data, []);
693// Check axesflag=5
694close
695x=(0.1:0.1:2*%pi)';
696plot2d(x, sin(x), axesflag=5);
697f=gcf();
698a=gca();
699c=a.children(1); //compound
700p=c.children(1); //polyline
701// Check axes
702assert_checkequal(a.visible, "on");
703assert_checkequal(a.axes_visible, ["on" "on" "on"]);
704assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
705assert_checkequal(a.grid, [-1 -1]);
706assert_checkequal(a.grid_position, "background");
707assert_checkequal(a.x_location, "middle");
708assert_checkequal(a.y_location, "middle");
709assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
710assert_checkequal(a.box, "on");
711assert_checkequal(a.filled, "on");
712assert_checkequal(a.sub_ticks, [0, 1]);
713assert_checkequal(a.font_style, 6);
714assert_checkequal(a.font_size, 1);
715assert_checkequal(a.font_color, -1);
716assert_checkequal(a.fractional_font, "off");
717assert_checkequal(a.isoview, "off");
718assert_checkequal(a.cube_scaling, "off");
719assert_checkequal(a.view, "2d");
720assert_checkequal(a.rotation_angles, [0, 270]);
721assert_checkequal(a.log_flags, "nnn");
722assert_checkequal(a.tight_limits, ["off", "off", "off"]);
723assert_checktrue(a.data_bounds - [0.1, 0.0415807; 6.2, 0.9995736] < 1d-7);
724assert_checkequal(a.zoom_box, []);
725assert_checkequal(a.margins, [0.125, 0.125, 0.125, 0.125]);
726assert_checkequal(a.axes_bounds, [0, 0, 1, 1]);
727assert_checkequal(a.auto_clear, "off");
728assert_checkequal(a.auto_scale, "on");
729assert_checkequal(a.hidden_axis_color, 4);
730assert_checkequal(a.hiddencolor, 4);
731assert_checkequal(a.line_mode, "on");
732assert_checkequal(a.line_style, 1);
733assert_checkequal(a.thickness, 1);
734assert_checkequal(a.mark_mode, "off");
735assert_checkequal(a.mark_style, 0);
736assert_checkequal(a.mark_size_unit, "tabulated");
737assert_checkequal(a.mark_size, 0);
738assert_checkequal(a.mark_foreground, -1);
739assert_checkequal(a.mark_background, -2);
740assert_checkequal(a.foreground, -1);
741assert_checkequal(a.background, -2);
742assert_checkequal(a.arc_drawing_method, "lines");
743assert_checkequal(a.clip_state, "clipgrf");
744assert_checkequal(a.clip_box, []);
745assert_checkequal(a.user_data, []);
746// Check caption with strf="181"
747close
748x=(0.1:0.1:2*%pi)';
749plot2d(x, sin(x), strf="181", leg="sinus");
750f=gcf();
751a=gca();
752c=a.children(1); //compound
753l=a.children(2); //legend
754p=c.children(1); //polyline
755// Check figure
756assert_checkequal(f.auto_resize, "on");
757assert_checkequal(f.viewport, [0,0]);
758assert_checkequal(f.figure_name, gettext("Graphic window number %d"));
759assert_checkequal(f.figure_id, 0);
760assert_checkequal(f.pixel_drawing_mode, "copy");
761assert_checkequal(f.anti_aliasing, "off");
762assert_checkequal(f.immediate_drawing, "on");
763assert_checkequal(f.background, -2);
764assert_checkequal(f.visible, "on");
765assert_checkequal(f.rotation_style, "unary");
766assert_checkequal(f.event_handler, "");
767assert_checkequal(f.event_handler_enable, "off");
768assert_checkequal(f.user_data, []);
769assert_checkequal(f.tag, "");
770// Check legend
771assert_checkequal(l.parent.type,"Axes");
772assert_checkequal(l.visible,"on");
773assert_checkequal(l.text,"sinus");
774assert_checkequal(l.font_style,6);
775assert_checkequal(l.font_size,1);
776assert_checkequal(l.font_color,-1);
777assert_checkequal(l.fractional_font,"off");
778assert_checkequal(l.links.type,"Polyline");
779assert_checkequal(l.legend_location,"lower_caption");
780assert_checktrue(l.position - [0.125,0.9375] < 1d-7);
781assert_checkequal(l.line_mode,"off");
782assert_checkequal(l.thickness,1);
783assert_checkequal(l.foreground,-1);
784assert_checkequal(l.fill_mode,"off");
785assert_checkequal(l.background,-2);
786assert_checkequal(l.clip_state,"off");
787assert_checkequal(l.clip_box,[]);
788assert_checkequal(l.user_data,[]);
789// Check frameflag=1
790close
791x=(0.1:0.1:2*%pi)';
792plot2d(x, sin(x), frameflag=1);
793f=gcf();
794a=gca();
795c=a.children(1); //compound
796p=c.children(1); //polyline
797// Check axes
798assert_checkequal(a.visible, "on");
799assert_checkequal(a.axes_visible, ["on" "on" "on"]);
800assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
801assert_checkequal(a.grid, [-1 -1]);
802assert_checkequal(a.grid_position, "background");
803assert_checkequal(a.x_location, "bottom");
804assert_checkequal(a.y_location, "left");
805assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
806assert_checkequal(a.box, "off");
807assert_checkequal(a.filled, "on");
808assert_checkequal(a.sub_ticks, [1, 1]);
809assert_checkequal(a.font_style, 6);
810assert_checkequal(a.font_size, 1);
811assert_checkequal(a.font_color, -1);
812assert_checkequal(a.fractional_font, "off");
813assert_checkequal(a.isoview, "off");
814assert_checkequal(a.cube_scaling, "off");
815assert_checkequal(a.view, "2d");
816assert_checkequal(a.rotation_angles, [0, 270]);
817assert_checkequal(a.log_flags, "nnn");
818assert_checkequal(a.tight_limits, ["on", "on", "on"]);
819assert_checkequal(a.data_bounds,[0, 0; 0, 0]);
820assert_checkequal(a.zoom_box, []);
821assert_checkequal(a.margins, [0.125, 0.125, 0.125, 0.125]);
822assert_checkequal(a.axes_bounds, [0, 0, 1, 1]);
823assert_checkequal(a.auto_clear, "off");
824assert_checkequal(a.auto_scale, "on");
825assert_checkequal(a.hidden_axis_color, 4);
826assert_checkequal(a.hiddencolor, 4);
827assert_checkequal(a.line_mode, "on");
828assert_checkequal(a.line_style, 1);
829assert_checkequal(a.thickness, 1);
830assert_checkequal(a.mark_mode, "off");
831assert_checkequal(a.mark_style, 0);
832assert_checkequal(a.mark_size_unit, "tabulated");
833assert_checkequal(a.mark_size, 0);
834assert_checkequal(a.mark_foreground, -1);
835assert_checkequal(a.mark_background, -2);
836assert_checkequal(a.foreground, -1);
837assert_checkequal(a.background, -2);
838assert_checkequal(a.arc_drawing_method, "lines");
839assert_checkequal(a.clip_state, "clipgrf");
840assert_checkequal(a.clip_box, []);
841assert_checkequal(a.user_data, []);
842// Check compound
843assert_checkequal(c.parent.type, "Axes");
844assert_checkequal(c.children(:).type, "Polyline");
845assert_checkequal(c.visible, "on");
846assert_checkequal(c.user_data, []);
847// Check polyline
848DefaultData=(0.1:0.1:2*%pi)';
849assert_checkequal(p.parent.type, "Compound");
850assert_checkequal(p.children, []);
851assert_checkequal(p.visible, "on");
852assert_checkequal(p.data, [DefaultData, sin(DefaultData)]);
853assert_checkequal(p.closed, "off");
854assert_checkequal(p.line_mode, "on");
855assert_checkequal(p.fill_mode, "off");
856assert_checkequal(p.line_style, 1);
857assert_checkequal(p.thickness, 1);
858assert_checkequal(p.arrow_size_factor, 1);
859assert_checkequal(p.polyline_style, 1);
860assert_checkequal(p.foreground, 1);
861assert_checkequal(p.background, -2);
862assert_checkequal(p.interp_color_vector, []);
863assert_checkequal(p.interp_color_mode, "off");
864assert_checkequal(p.mark_mode, "off");
865assert_checkequal(p.mark_style, 0);
866assert_checkequal(p.mark_size_unit, "tabulated");
867assert_checkequal(p.mark_size, 0);
868assert_checkequal(p.mark_foreground, -1);
869assert_checkequal(p.mark_background, -2);
870assert_checkequal(p.x_shift, []);
871assert_checkequal(p.y_shift, []);
872assert_checkequal(p.z_shift, []);
873assert_checkequal(p.bar_width, 0);
874assert_checkequal(p.clip_state, "clipgrf");
875assert_checkequal(p.clip_box, []);
876assert_checkequal(p.user_data, []);
877// Check frameflag=2
878close
879x=(0.1:0.1:2*%pi)';
880plot2d(x, sin(x), frameflag=2);
881f=gcf();
882a=gca();
883c=a.children(1); //compound
884p=c.children(1); //polyline
885// Check axes
886assert_checkequal(a.visible, "on");
887assert_checkequal(a.axes_visible, ["on" "on" "on"]);
888assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
889assert_checkequal(a.grid, [-1 -1]);
890assert_checkequal(a.grid_position, "background");
891assert_checkequal(a.x_location, "bottom");
892assert_checkequal(a.y_location, "left");
893assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
894assert_checkequal(a.box, "off");
895assert_checkequal(a.filled, "on");
896assert_checkequal(a.sub_ticks, [0, 1]);
897assert_checkequal(a.font_style, 6);
898assert_checkequal(a.font_size, 1);
899assert_checkequal(a.font_color, -1);
900assert_checkequal(a.fractional_font, "off");
901assert_checkequal(a.isoview, "off");
902assert_checkequal(a.cube_scaling, "off");
903assert_checkequal(a.view, "2d");
904assert_checkequal(a.rotation_angles, [0, 270]);
905assert_checkequal(a.log_flags, "nnn");
906assert_checkequal(a.tight_limits, ["on", "on", "on"]);
907assert_checktrue(a.data_bounds - [0.1, -0.9999233; 6.2, 0.9995736] < 1d-7);
908assert_checkequal(a.zoom_box, []);
909assert_checkequal(a.margins, [0.125, 0.125, 0.125, 0.125]);
910assert_checkequal(a.axes_bounds, [0, 0, 1, 1]);
911assert_checkequal(a.auto_clear, "off");
912assert_checkequal(a.auto_scale, "on");
913assert_checkequal(a.hidden_axis_color, 4);
914assert_checkequal(a.hiddencolor, 4);
915assert_checkequal(a.line_mode, "on");
916assert_checkequal(a.line_style, 1);
917assert_checkequal(a.thickness, 1);
918assert_checkequal(a.mark_mode, "off");
919assert_checkequal(a.mark_style, 0);
920assert_checkequal(a.mark_size_unit, "tabulated");
921assert_checkequal(a.mark_size, 0);
922assert_checkequal(a.mark_foreground, -1);
923assert_checkequal(a.mark_background, -2);
924assert_checkequal(a.foreground, -1);
925assert_checkequal(a.background, -2);
926assert_checkequal(a.arc_drawing_method, "lines");
927assert_checkequal(a.clip_state, "clipgrf");
928assert_checkequal(a.clip_box, []);
929assert_checkequal(a.user_data, []);
930// Check frameflag=3
931close
932x=(0.1:0.1:2*%pi)';
933plot2d(x, sin(x), frameflag=3);
934f=gcf();
935a=gca();
936c=a.children(1); //compound
937p=c.children(1); //polyline
938// Check axes
939assert_checkequal(a.visible, "on");
940assert_checkequal(a.axes_visible, ["on" "on" "on"]);
941assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
942assert_checkequal(a.grid, [-1 -1]);
943assert_checkequal(a.grid_position, "background");
944assert_checkequal(a.x_location, "bottom");
945assert_checkequal(a.y_location, "left");
946assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
947assert_checkequal(a.box, "off");
948assert_checkequal(a.filled, "on");
949assert_checkequal(a.sub_ticks, [1, 1]);
950assert_checkequal(a.isoview, "on");
951assert_checkequal(a.rotation_angles, [0, 270]);
952assert_checkequal(a.tight_limits, ["off", "off", "off"]);
953assert_checkequal(a.data_bounds, [0, 0; 0, 0]);
954// Check frameflag=4
955close
956x=(0.1:0.1:2*%pi)';
957plot2d(x, sin(x), frameflag=4);
958f=gcf();
959a=gca();
960c=a.children(1); //compound
961p=c.children(1); //polyline
962// Check axes
963assert_checkequal(a.visible, "on");
964assert_checkequal(a.axes_visible, ["on" "on" "on"]);
965assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
966assert_checkequal(a.grid, [-1 -1]);
967assert_checkequal(a.grid_position, "background");
968assert_checkequal(a.x_location, "bottom");
969assert_checkequal(a.y_location, "left");
970assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
971assert_checkequal(a.box, "off");
972assert_checkequal(a.filled, "on");
973assert_checkequal(a.sub_ticks, [0, 0]);
974assert_checkequal(a.isoview, "on");
975assert_checkequal(a.rotation_angles, [0, 270]);
976assert_checkequal(a.tight_limits, ["off", "off", "off"]);
977assert_checktrue(a.data_bounds - [0.1, -0.9999233; 6.2, 0.9995736] < 1d-7);
978// Check frameflag=5
979close
980x=(0.1:0.1:2*%pi)';
981plot2d(x, sin(x), frameflag=5);
982f=gcf();
983a=gca();
984c=a.children(1); //compound
985p=c.children(1); //polyline
986// Check axes
987assert_checkequal(a.visible, "on");
988assert_checkequal(a.axes_visible, ["on" "on" "on"]);
989assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
990assert_checkequal(a.grid, [-1 -1]);
991assert_checkequal(a.grid_position, "background");
992assert_checkequal(a.x_location, "bottom");
993assert_checkequal(a.y_location, "left");
994assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
995assert_checkequal(a.box, "off");
996assert_checkequal(a.filled, "on");
997assert_checkequal(a.sub_ticks, [1, 1]);
998assert_checkequal(a.isoview, "off");
999assert_checkequal(a.rotation_angles, [0, 270]);
1000assert_checkequal(a.tight_limits, ["off", "off", "off"]);
1001assert_checkequal(a.data_bounds, [0, 0; 0, 0]);
1002// Check frameflag=6
1003close
1004x=(0.1:0.1:2*%pi)';
1005plot2d(x, sin(x), frameflag=6);
1006f=gcf();
1007a=gca();
1008c=a.children(1); //compound
1009p=c.children(1); //polyline
1010// Check axes
1011assert_checkequal(a.visible, "on");
1012assert_checkequal(a.axes_visible, ["on" "on" "on"]);
1013assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
1014assert_checkequal(a.grid, [-1 -1]);
1015assert_checkequal(a.grid_position, "background");
1016assert_checkequal(a.x_location, "bottom");
1017assert_checkequal(a.y_location, "left");
1018assert_checkequal(a.auto_ticks, ["on" "on" "on"]);
1019assert_checkequal(a.box, "off");
1020assert_checkequal(a.filled, "on");
1021assert_checkequal(a.sub_ticks, [0, 1]);
1022assert_checkequal(a.isoview, "off");
1023assert_checkequal(a.rotation_angles, [0, 270]);
1024assert_checkequal(a.tight_limits, ["off", "off", "off"]);
1025assert_checktrue(a.data_bounds - [0.1, -0.9999233; 6.2, 0.9995736] < 1d-7);
1026// Check nax
1027close
1028x=(0.1:0.1:2*%pi)';
1029plot2d(x, sin(x), nax=[2,10,2,10]);
1030f=gcf();
1031a=gca();
1032c=a.children(1); //compound
1033p=c.children(1); //polyline
1034// Check axes
1035assert_checkequal(a.visible, "on");
1036assert_checkequal(a.axes_visible, ["on" "on" "on"]);
1037assert_checkequal(a.axes_reverse, ["off" "off" "off"]);
1038assert_checkequal(a.grid, [-1 -1]);
1039assert_checkequal(a.grid_position, "background");
1040assert_checkequal(a.x_location, "bottom");
1041assert_checkequal(a.y_location, "left");
1042assert_checkequal(a.auto_ticks, ["off" "off" "on"]);
1043assert_checkequal(a.box, "off");
1044assert_checkequal(a.filled, "on");
1045assert_checkequal(a.sub_ticks, [2, 2]);
1046assert_checkequal(a.font_style, 6);
1047assert_checkequal(a.font_size, 1);
1048assert_checkequal(a.font_color, -1);
1049assert_checkequal(a.fractional_font, "off");
1050assert_checkequal(a.isoview, "off");
1051assert_checkequal(a.cube_scaling, "off");
1052assert_checkequal(a.view, "2d");
1053assert_checkequal(a.rotation_angles, [0, 270]);
1054assert_checkequal(a.log_flags, "nnn");
1055assert_checkequal(a.tight_limits, ["off", "off", "off"]);
1056assert_checktrue(a.data_bounds - [0.1, -0.9999233; 6.2, 0.9995736] < 1d-7);
1057assert_checkequal(a.zoom_box, []);
1058assert_checkequal(a.margins, [0.125, 0.125, 0.125, 0.125]);
1059assert_checkequal(a.axes_bounds, [0, 0, 1, 1]);
1060assert_checkequal(a.auto_clear, "off");
1061assert_checkequal(a.auto_scale, "on");
1062assert_checkequal(a.hidden_axis_color, 4);
1063assert_checkequal(a.hiddencolor, 4);
1064assert_checkequal(a.line_mode, "on");
1065assert_checkequal(a.line_style, 1);
1066assert_checkequal(a.thickness, 1);
1067assert_checkequal(a.mark_mode, "off");
1068assert_checkequal(a.mark_style, 0);
1069assert_checkequal(a.mark_size_unit, "tabulated");
1070assert_checkequal(a.mark_size, 0);
1071assert_checkequal(a.mark_foreground, -1);
1072assert_checkequal(a.mark_background, -2);
1073assert_checkequal(a.foreground, -1);
1074assert_checkequal(a.background, -2);
1075assert_checkequal(a.arc_drawing_method, "lines");
1076assert_checkequal(a.clip_state, "clipgrf");
1077assert_checkequal(a.clip_box, []);
1078assert_checkequal(a.user_data, []);
1079close
1080