corrade-http-templates – Blame information for rev 62
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
62 | office | 1 | define( [ |
2 | "qunit", |
||
3 | "jquery", |
||
4 | "ui/widgets/spinner", |
||
5 | "globalize", |
||
6 | "globalize/ja-JP" |
||
7 | ], function( QUnit, $ ) { |
||
8 | |||
9 | QUnit.module( "spinner: options" ); |
||
10 | |||
11 | // Culture is tested after numberFormat, since it depends on numberFormat |
||
12 | |||
13 | QUnit.test( "icons: default ", function( assert ) { |
||
14 | assert.expect( 4 ); |
||
15 | var element = $( "#spin" ).val( 0 ).spinner(); |
||
16 | assert.hasClasses( element.spinner( "widget" ).find( ".ui-icon:first" ), |
||
17 | "ui-icon ui-icon-triangle-1-n" ); |
||
18 | assert.hasClasses( element.spinner( "widget" ).find( ".ui-icon:last" ), |
||
19 | "ui-icon ui-icon-triangle-1-s" ); |
||
20 | |||
21 | element.spinner( "option", "icons", { |
||
22 | up: "ui-icon-caret-1-n", |
||
23 | down: "ui-icon-caret-1-s" |
||
24 | } ); |
||
25 | assert.hasClasses( element.spinner( "widget" ).find( ".ui-icon:first" ), |
||
26 | "ui-icon ui-icon-caret-1-n" ); |
||
27 | assert.hasClasses( element.spinner( "widget" ).find( ".ui-icon:last" ), |
||
28 | "ui-icon ui-icon-caret-1-s" ); |
||
29 | } ); |
||
30 | |||
31 | QUnit.test( "icons: custom ", function( assert ) { |
||
32 | assert.expect( 2 ); |
||
33 | var element = $( "#spin" ).val( 0 ).spinner( { |
||
34 | icons: { |
||
35 | down: "custom-down", |
||
36 | up: "custom-up" |
||
37 | } |
||
38 | } ).spinner( "widget" ); |
||
39 | assert.hasClasses( element.find( ".ui-icon:first" ), "ui-icon custom-up" ); |
||
40 | assert.hasClasses( element.find( ".ui-icon:last" ), "ui-icon custom-down" ); |
||
41 | } ); |
||
42 | |||
43 | QUnit.test( "incremental, false", function( assert ) { |
||
44 | assert.expect( 100 ); |
||
45 | |||
46 | var i, |
||
47 | prev = 0, |
||
48 | element = $( "#spin" ).val( prev ).spinner( { |
||
49 | incremental: false, |
||
50 | spin: function( event, ui ) { |
||
51 | assert.equal( ui.value - prev, 1 ); |
||
52 | prev = ui.value; |
||
53 | } |
||
54 | } ); |
||
55 | |||
56 | for ( i = 0; i < 100; i++ ) { |
||
57 | element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } ); |
||
58 | } |
||
59 | element.simulate( "keyup", { keyCode: $.ui.keyCode.UP } ); |
||
60 | } ); |
||
61 | |||
62 | QUnit.test( "incremental, true", function( assert ) { |
||
63 | assert.expect( 100 ); |
||
64 | |||
65 | function fill( num, val ) { |
||
66 | return $.map( new Array( num ), function() { |
||
67 | return val; |
||
68 | } ); |
||
69 | } |
||
70 | |||
71 | var i, |
||
72 | prev = 0, |
||
73 | expected = [].concat( fill( 18, 1 ), fill( 37, 2 ), fill( 14, 3 ), |
||
74 | fill( 9, 4 ), fill( 6, 5 ), fill( 5, 6 ), fill( 5, 7 ), |
||
75 | fill( 4, 8 ), fill( 2, 9 ) ), |
||
76 | element = $( "#spin" ).val( prev ).spinner( { |
||
77 | incremental: true, |
||
78 | spin: function( event, ui ) { |
||
79 | assert.equal( ui.value - prev, expected[ i ] ); |
||
80 | prev = ui.value; |
||
81 | } |
||
82 | } ); |
||
83 | |||
84 | for ( i = 0; i < 100; i++ ) { |
||
85 | element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } ); |
||
86 | } |
||
87 | element.simulate( "keyup", { keyCode: $.ui.keyCode.UP } ); |
||
88 | } ); |
||
89 | |||
90 | QUnit.test( "incremental, function", function( assert ) { |
||
91 | assert.expect( 100 ); |
||
92 | |||
93 | var i, |
||
94 | prev = 0, |
||
95 | element = $( "#spin" ).val( prev ).spinner( { |
||
96 | incremental: function( i ) { |
||
97 | return i; |
||
98 | }, |
||
99 | spin: function( event, ui ) { |
||
100 | assert.equal( ui.value - prev, i + 1 ); |
||
101 | prev = ui.value; |
||
102 | } |
||
103 | } ); |
||
104 | |||
105 | for ( i = 0; i < 100; i++ ) { |
||
106 | element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } ); |
||
107 | } |
||
108 | element.simulate( "keyup", { keyCode: $.ui.keyCode.UP } ); |
||
109 | } ); |
||
110 | |||
111 | QUnit.test( "numberFormat, number", function( assert ) { |
||
112 | assert.expect( 2 ); |
||
113 | var element = $( "#spin" ).val( 0 ).spinner( { numberFormat: "n" } ); |
||
114 | assert.equal( element.val(), "0.00", "formatted on init" ); |
||
115 | element.spinner( "stepUp" ); |
||
116 | assert.equal( element.val(), "1.00", "formatted after step" ); |
||
117 | } ); |
||
118 | |||
119 | QUnit.test( "numberFormat, number, simple", function( assert ) { |
||
120 | assert.expect( 2 ); |
||
121 | var element = $( "#spin" ).val( 0 ).spinner( { numberFormat: "n0" } ); |
||
122 | assert.equal( element.val(), "0", "formatted on init" ); |
||
123 | element.spinner( "stepUp" ); |
||
124 | assert.equal( element.val(), "1", "formatted after step" ); |
||
125 | } ); |
||
126 | |||
127 | QUnit.test( "numberFormat, currency", function( assert ) { |
||
128 | assert.expect( 2 ); |
||
129 | var element = $( "#spin" ).val( 0 ).spinner( { numberFormat: "C" } ); |
||
130 | assert.equal( element.val(), "$0.00", "formatted on init" ); |
||
131 | element.spinner( "stepUp" ); |
||
132 | assert.equal( element.val(), "$1.00", "formatted after step" ); |
||
133 | } ); |
||
134 | |||
135 | QUnit.test( "numberFormat, change", function( assert ) { |
||
136 | assert.expect( 2 ); |
||
137 | var element = $( "#spin" ).val( 5 ).spinner( { numberFormat: "n1" } ); |
||
138 | assert.equal( element.val(), "5.0", "formatted on init" ); |
||
139 | element.spinner( "option", "numberFormat", "c" ); |
||
140 | assert.equal( element.val(), "$5.00", "formatted after change" ); |
||
141 | } ); |
||
142 | |||
143 | QUnit.test( "culture, null", function( assert ) { |
||
144 | assert.expect( 2 ); |
||
145 | Globalize.culture( "ja-JP" ); |
||
146 | var element = $( "#spin" ).val( 0 ).spinner( { numberFormat: "C" } ); |
||
147 | assert.equal( element.val(), "¥0", "formatted on init" ); |
||
148 | element.spinner( "stepUp" ); |
||
149 | assert.equal( element.val(), "¥1", "formatted after step" ); |
||
150 | |||
151 | // Reset culture |
||
152 | Globalize.culture( "default" ); |
||
153 | } ); |
||
154 | |||
155 | QUnit.test( "currency, ja-JP", function( assert ) { |
||
156 | assert.expect( 2 ); |
||
157 | var element = $( "#spin" ).val( 0 ).spinner( { |
||
158 | numberFormat: "C", |
||
159 | culture: "ja-JP" |
||
160 | } ); |
||
161 | assert.equal( element.val(), "¥0", "formatted on init" ); |
||
162 | element.spinner( "stepUp" ); |
||
163 | assert.equal( element.val(), "¥1", "formatted after step" ); |
||
164 | } ); |
||
165 | |||
166 | QUnit.test( "currency, change", function( assert ) { |
||
167 | assert.expect( 2 ); |
||
168 | var element = $( "#spin" ).val( 5 ).spinner( { |
||
169 | numberFormat: "C", |
||
170 | culture: "ja-JP" |
||
171 | } ); |
||
172 | assert.equal( element.val(), "¥5", "formatted on init" ); |
||
173 | element.spinner( "option", "culture", "en" ); |
||
174 | assert.equal( element.val(), "$5.00", "formatted after change" ); |
||
175 | } ); |
||
176 | |||
177 | QUnit.test( "max", function( assert ) { |
||
178 | assert.expect( 3 ); |
||
179 | var element = $( "#spin" ).val( 1000 ).spinner( { max: 100 } ); |
||
180 | assert.equal( element.val(), 1000, "value not constrained on init" ); |
||
181 | |||
182 | element.spinner( "value", 1000 ); |
||
183 | assert.equal( element.val(), 100, "max constrained in value method" ); |
||
184 | |||
185 | element.val( 1000 ).trigger( "blur" ); |
||
186 | assert.equal( element.val(), 1000, "max not constrained if manual entry" ); |
||
187 | } ); |
||
188 | |||
189 | QUnit.test( "max, string", function( assert ) { |
||
190 | assert.expect( 3 ); |
||
191 | var element = $( "#spin" ) |
||
192 | .val( 1000 ) |
||
193 | .spinner( { |
||
194 | max: "$100.00", |
||
195 | numberFormat: "C", |
||
196 | culture: "en" |
||
197 | } ); |
||
198 | assert.equal( element.val(), "$1,000.00", "value not constrained on init" ); |
||
199 | assert.equal( element.spinner( "option", "max" ), 100, "option converted to number" ); |
||
200 | |||
201 | element.spinner( "value", 1000 ); |
||
202 | assert.equal( element.val(), "$100.00", "max constrained in value method" ); |
||
203 | } ); |
||
204 | |||
205 | QUnit.test( "min", function( assert ) { |
||
206 | assert.expect( 3 ); |
||
207 | var element = $( "#spin" ).val( -1000 ).spinner( { min: -100 } ); |
||
208 | assert.equal( element.val(), -1000, "value not constrained on init" ); |
||
209 | |||
210 | element.spinner( "value", -1000 ); |
||
211 | assert.equal( element.val(), -100, "min constrained in value method" ); |
||
212 | |||
213 | element.val( -1000 ).trigger( "blur" ); |
||
214 | assert.equal( element.val(), -1000, "min not constrained if manual entry" ); |
||
215 | } ); |
||
216 | |||
217 | QUnit.test( "min, string", function( assert ) { |
||
218 | assert.expect( 3 ); |
||
219 | var element = $( "#spin" ) |
||
220 | .val( -1000 ) |
||
221 | .spinner( { |
||
222 | min: "-$100.00", |
||
223 | numberFormat: "C", |
||
224 | culture: "en" |
||
225 | } ); |
||
226 | assert.equal( element.val(), "($1,000.00)", "value not constrained on init" ); |
||
227 | assert.equal( element.spinner( "option", "min" ), -100, "option converted to number" ); |
||
228 | |||
229 | element.spinner( "value", -1000 ); |
||
230 | assert.equal( element.val(), "($100.00)", "min constrained in value method" ); |
||
231 | } ); |
||
232 | |||
233 | QUnit.test( "step, 2", function( assert ) { |
||
234 | assert.expect( 3 ); |
||
235 | var element = $( "#spin" ).val( 0 ).spinner( { step: 2 } ); |
||
236 | |||
237 | element.spinner( "stepUp" ); |
||
238 | assert.equal( element.val(), "2", "stepUp" ); |
||
239 | |||
240 | element.spinner( "value", "10.5" ); |
||
241 | assert.equal( element.val(), "10", "value reset to 10" ); |
||
242 | |||
243 | element.val( "4.5" ); |
||
244 | element.spinner( "stepUp" ); |
||
245 | assert.equal( element.val(), "6", "stepUp" ); |
||
246 | } ); |
||
247 | |||
248 | QUnit.test( "step, 0.7", function( assert ) { |
||
249 | assert.expect( 1 ); |
||
250 | var element = $( "#spin" ).val( 0 ).spinner( { |
||
251 | step: 0.7 |
||
252 | } ); |
||
253 | |||
254 | element.spinner( "stepUp" ); |
||
255 | assert.equal( element.val(), "0.7", "stepUp" ); |
||
256 | } ); |
||
257 | |||
258 | QUnit.test( "step, string", function( assert ) { |
||
259 | assert.expect( 2 ); |
||
260 | var element = $( "#spin" ).val( 0 ).spinner( { |
||
261 | step: "$0.70", |
||
262 | numberFormat: "C", |
||
263 | culture: "en" |
||
264 | } ); |
||
265 | |||
266 | assert.equal( element.spinner( "option", "step" ), 0.7, "option converted to number" ); |
||
267 | |||
268 | element.spinner( "stepUp" ); |
||
269 | assert.equal( element.val(), "$0.70", "stepUp" ); |
||
270 | } ); |
||
271 | |||
272 | } ); |