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