Graphics: fix datatip rendering after 5f1861ec
[scilab.git] / scilab / modules / ast / tests / unit_tests / concatenation.dia.ref
1 // ============================================================================
2 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 // Copyright (C) 2014 - Scilab Enterprises - Cedric Delamarre
4 //
5 //  This file is distributed under the same license as the Scilab package.
6 // ============================================================================
7 // <-- CLI SHELL MODE -->
8 function checkCallOverload(mat)
9     assert_checkerror(mat, [], 999);
10 endfunction
11 ldouble = [1 2 3];
12 lbool   = [%t %f %t];
13 lint    = [int32(1) int32(2) int32(3)];
14 lint16  = [int16(1) int16(2) int16(3)];
15 lpoly   = [%s %s^2 %s];
16 lsparse = [sparse(1) sparse(2) sparse(3)];
17 lspb    = [sparse(%t) sparse(%f) sparse(%t)];
18 lstring = ["Scilab" "Enterprises" "2014"];
19 sta.x   = 12;
20 lsta    = [sta sta sta];
21 // list, tlist, mlist
22 checkCallOverload("[list(1) list(2)]");
23 // Double
24 assert_checkequal([ldouble ldouble], [1 2 3 1 2 3]);
25 assert_checkequal([ldouble lbool], [ldouble double(lbool)]);
26 checkCallOverload("[ldouble lint]");
27 checkCallOverload("[ldouble lint16]");
28 assert_checkequal([ldouble lpoly], [(ldouble + 0*%s) lpoly]);
29 assert_checkequal([ldouble lsparse], [sparse(ldouble) lsparse]);
30 checkCallOverload("[ldouble lspb]");
31 checkCallOverload("[ldouble lstring]");
32 checkCallOverload("[ldouble lsta]");
33 assert_checkequal([ldouble ; ldouble], matrix([1 1 2 2 3 3], 2, 3));
34 assert_checkequal([ldouble ; lbool], [ldouble ; double(lbool)]);
35 checkCallOverload("[ldouble ; lint]");
36 checkCallOverload("[ldouble ; lint16]");
37 assert_checkequal([ldouble ; lpoly], [(ldouble + 0*%s) ; lpoly]);
38 assert_checkequal([ldouble ; lsparse], [sparse(ldouble) ; lsparse]);
39 checkCallOverload("[ldouble ; lspb]");
40 checkCallOverload("[ldouble ; lstring]");
41 checkCallOverload("[ldouble ; lsta]");
42 // Bool
43 assert_checkequal([lbool ldouble], [double(lbool) ldouble]);
44 assert_checkequal([lbool lbool], [%t %f %t %t %f %t]);
45 checkCallOverload("[lbool lint]");
46 checkCallOverload("[lbool lint16]");
47 checkCallOverload("[lbool lpoly]");
48 checkCallOverload("[lbool lsparse]");
49 assert_checkequal([lbool lspb], [sparse(lbool) lspb]);
50 checkCallOverload("[lbool lstring]");
51 checkCallOverload("[lbool lsta]");
52 assert_checkequal([lbool ; ldouble], [double(lbool) ; ldouble]);
53 assert_checkequal([lbool ; lbool], matrix([%t %t %f %f %t %t], 2, 3));
54 checkCallOverload("[lbool ; lint]");
55 checkCallOverload("[lbool ; lint16]");
56 checkCallOverload("[lbool ; lpoly]");
57 checkCallOverload("[lbool ; lsparse]");
58 assert_checkequal([lbool ; lspb], [sparse(lbool) ; lspb]);
59 checkCallOverload("[lbool ; lstring]");
60 checkCallOverload("[lbool ; lsta]");
61 // int
62 checkCallOverload("[lint ldouble]");
63 checkCallOverload("[lint lbool]");
64 assert_checkequal([lint lint], int32([1 2 3 1 2 3]));
65 checkCallOverload("[lint lint16]");
66 checkCallOverload("[lint lpoly]");
67 checkCallOverload("[lint lsparse]");
68 checkCallOverload("[lint lspb]");
69 checkCallOverload("[lint lstring]");
70 checkCallOverload("[lint lsta]");
71 checkCallOverload("[lint ; ldouble]");
72 checkCallOverload("[lint ; lbool]");
73 assert_checkequal([lint ; lint], int32(matrix([1 1 2 2 3 3], 2, 3)));
74 checkCallOverload("[lint ; lint16]");
75 checkCallOverload("[lint ; lpoly]");
76 checkCallOverload("[lint ; lsparse]");
77 checkCallOverload("[lint ; lspb]");
78 checkCallOverload("[lint  lstring]");
79 checkCallOverload("[lint ; lsta]");
80 // polynom
81 assert_checkequal([lpoly ldouble], [%s %s^2 %s 1 2 3]);
82 checkCallOverload("[lpoly lbool]");
83 checkCallOverload("[lpoly lint]");
84 checkCallOverload("[lpoly lint16]");
85 assert_checkequal([lpoly lpoly], [%s %s^2 %s %s %s^2 %s]);
86 checkCallOverload("[lpoly lsparse]");
87 checkCallOverload("[lpoly lspb]");
88 checkCallOverload("[lpoly lstring]");
89 checkCallOverload("[lpoly lsta]");
90 assert_checkequal([lpoly ; ldouble], matrix([%s 1 %s^2 2 %s 3], 2, 3));
91 checkCallOverload("[lpoly ; lbool]");
92 checkCallOverload("[lpoly ; lint]");
93 checkCallOverload("[lpoly ; lint16]");
94 assert_checkequal([lpoly ; lpoly], matrix([%s %s %s^2 %s^2 %s %s], 2, 3));
95 checkCallOverload("[lpoly ; lsparse]");
96 checkCallOverload("[lpoly ; lspb]");
97 checkCallOverload("[lpoly ; lstring]");
98 checkCallOverload("[lpoly ; lsta]");
99 // sparse
100 assert_checkequal([lsparse ldouble], sparse([1 2 3 1 2 3]));
101 checkCallOverload("[lsparse lbool]");
102 checkCallOverload("[lsparse lint]");
103 checkCallOverload("[lsparse lint16]");
104 checkCallOverload("[lsparse lpoly]");
105 assert_checkequal([lsparse lsparse], sparse([1 2 3 1 2 3]));
106 checkCallOverload("[lsparse lspb]");
107 checkCallOverload("[lsparse lstring]");
108 checkCallOverload("[lsparse lsta]");
109 assert_checkequal([lsparse ; ldouble], sparse(matrix([1 1 2 2 3 3], 2, 3)));
110 checkCallOverload("[lsparse  ;lbool]");
111 checkCallOverload("[lsparse ; lint]");
112 checkCallOverload("[lsparse ; lint16]");
113 checkCallOverload("[lsparse ; lpoly]");
114 assert_checkequal([lsparse ; lsparse], sparse(matrix([1 1 2 2 3 3], 2, 3)));
115 checkCallOverload("[lsparse ; lspb]");
116 checkCallOverload("[lsparse ; lstring]");
117 checkCallOverload("[lsparse ; lsta]");
118 // boolean sparse
119 checkCallOverload("[lspb ldouble]");
120 assert_checkequal([lspb lbool], sparse([%t %f %t %t %f %t]));
121 checkCallOverload("[lspb lint]");
122 checkCallOverload("[lspb lint16]");
123 checkCallOverload("[lspb lpoly]");
124 checkCallOverload("[lspb lsparse]");
125 assert_checkequal([lspb lspb], sparse([%t %f %t %t %f %t]));
126 checkCallOverload("[lspb lstring]");
127 checkCallOverload("[lspb lsta]");
128 checkCallOverload("[lspb ; ldouble]");
129 assert_checkequal([lspb ; lbool], sparse(matrix([%t %t %f %f %t %t], 2 ,3)));
130 checkCallOverload("[lspb ; lint]");
131 checkCallOverload("[lspb ; lint16]");
132 checkCallOverload("[lspb ; lpoly]");
133 checkCallOverload("[lspb ; lsparse]");
134 assert_checkequal([lspb ; lspb], sparse(matrix([%t %t %f %f %t %t], 2 ,3)));
135 checkCallOverload("[lspb ; lstring]");
136 checkCallOverload("[lspb ; lsta]");
137 // string
138 checkCallOverload("[lstring ldouble]");
139 checkCallOverload("[lstring lbool]");
140 checkCallOverload("[lstring lint]");
141 checkCallOverload("[lstring lint16]");
142 checkCallOverload("[lstring lpoly]");
143 checkCallOverload("[lstring lsparse]");
144 checkCallOverload("[lstring lspb]");
145 assert_checkequal([lstring lstring], ["Scilab" "Enterprises" "2014" "Scilab" "Enterprises" "2014"]);
146 checkCallOverload("[lstring lsta]");
147 checkCallOverload("[lstring ; ldouble]");
148 checkCallOverload("[lstring ; lbool]");
149 checkCallOverload("[lstring ; lint]");
150 checkCallOverload("[lstring ; lint16]");
151 checkCallOverload("[lstring ; lpoly]");
152 checkCallOverload("[lstring ; lsparse]");
153 checkCallOverload("[lstring ; lspb]");
154 assert_checkequal([lstring ; lstring], matrix(["Scilab" "Scilab" "Enterprises" "Enterprises" "2014" "2014"], 2, 3));
155 checkCallOverload("[lstring ; lsta]");
156 // struct
157 stb.y = 23;
158 stc.x = 56;
159 lstb  = [stb stb stb];
160 lstc  = [stc stc stc];
161 checkCallOverload("[lsta ldouble]");
162 checkCallOverload("[lsta lbool]");
163 checkCallOverload("[lsta lint]");
164 checkCallOverload("[lsta lint16]");
165 checkCallOverload("[lsta lpoly]");
166 checkCallOverload("[lsta lsparse]");
167 checkCallOverload("[lsta lspb]");
168 checkCallOverload("[lsta lstring]");
169 assert_checkequal([lsta lsta], [sta sta sta sta sta sta]);
170 assert_checkerror("[lsta ; lstb]", msprintf(_("%s: Field names mismatch.\n"),"%st_c_st"), 10000);
171 checkCallOverload("[lsta ; ldouble]");
172 checkCallOverload("[lsta ; lbool]");
173 checkCallOverload("[lsta ; lint]");
174 checkCallOverload("[lsta ; lint16]");
175 checkCallOverload("[lsta ; lpoly]");
176 checkCallOverload("[lsta ; lsparse]");
177 checkCallOverload("[lsta ; lspb]");
178 checkCallOverload("[lsta ; lstring]");
179 assert_checkequal([lsta ; lsta], matrix([sta sta sta sta sta sta], 2, 3));
180 assert_checkerror("[lsta ; lstb]", msprintf(_("%s: Field names mismatch.\n"),"%st_c_st"), 10000);
181 // ImplicitList
182 checkCallOverload("[1:$ 2]");
183 checkCallOverload("[1:$ 1:2]");
184 checkCallOverload("[1:$ int8(2)]");
185 checkCallOverload("[1:2 1:$]");
186 checkCallOverload("[1:$ 1:$]");
187 assert_checkequal([1:3 1:3], [1 2 3 1 2 3]);
188 checkCallOverload("[1:$ ; 2]");
189 checkCallOverload("[1:$ ; 1:2]");
190 checkCallOverload("[1:$ ; int8(2)]");
191 checkCallOverload("[1:2 ; 1:$]");
192 checkCallOverload("[1:$ ; 1:$]");
193 assert_checkequal([1:3 ; 1:3], matrix([1 1 2 2 3 3], 2, 3));