unit/spinner/spinner_options.js

(function( $ ) {

module( "spinner: options" );

// culture is tested after numberFormat, since it depends on numberFormat

test( "icons: default ", function() {
        expect( 4 );
        var element = $( "#spin" ).val( 0 ).spinner();
        equal( element.spinner( "widget" ).find( ".ui-icon:first" ).attr( "class" ), "ui-icon ui-icon-triangle-1-n" );
        equal( element.spinner( "widget" ).find( ".ui-icon:last" ).attr( "class" ), "ui-icon ui-icon-triangle-1-s" );

        element.spinner( "option", "icons", {
                up: "ui-icon-carat-1-n",
                down: "ui-icon-carat-1-s"
        });
        equal( element.spinner( "widget" ).find( ".ui-icon:first" ).attr( "class" ), "ui-icon ui-icon-carat-1-n" );
        equal( element.spinner( "widget" ).find( ".ui-icon:last" ).attr( "class" ), "ui-icon ui-icon-carat-1-s" );
});

test( "icons: custom ", function() {
        expect( 2 );
        var element = $( "#spin" ).val( 0 ).spinner({
                icons: {
                        down: "custom-down",
                        up: "custom-up"
                }
        }).spinner( "widget" );
        equal( element.find( ".ui-icon:first" ).attr( "class" ), "ui-icon custom-up" );
        equal( element.find( ".ui-icon:last" ).attr( "class" ), "ui-icon custom-down" );
});

test( "incremental, false", function() {
        expect( 100 );

        var i,
                prev = 0,
                element = $( "#spin" ).val( prev ).spinner({
                        incremental: false,
                        spin: function( event, ui ) {
                                equal( ui.value - prev, 1 );
                                prev = ui.value;
                        }
                });

        for ( i = 0; i < 100; i++ ) {
                element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
        }
        element.simulate( "keyup", { keyCode: $.ui.keyCode.UP } );
});

test( "incremental, true", function() {
        expect( 100 );

        function fill( num, val ) {
                return $.map( new Array( num ), function() {
                        return val;
                });
        }

        var i,
                prev = 0,
                expected = [].concat( fill( 18, 1 ), fill( 37, 2 ), fill( 14, 3 ),
                        fill( 9, 4 ), fill( 6, 5 ), fill( 5, 6 ), fill ( 5, 7 ),
                        fill( 4, 8 ), fill( 2, 9 ) ),
                element = $( "#spin" ).val( prev ).spinner({
                        incremental: true,
                        spin: function( event, ui ) {
                                equal( ui.value - prev, expected[ i ] );
                                prev = ui.value;
                        }
                });

        for ( i = 0; i < 100; i++ ) {
                element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
        }
        element.simulate( "keyup", { keyCode: $.ui.keyCode.UP } );
});

test( "incremental, function", function() {
        expect( 100 );

        var i,
                prev = 0,
                element = $( "#spin" ).val( prev ).spinner({
                        incremental: function( i ) {
                                return i;
                        },
                        spin: function( event, ui ) {
                                equal( ui.value - prev, i + 1 );
                                prev = ui.value;
                        }
                });

        for ( i = 0; i < 100; i++ ) {
                element.simulate( "keydown", { keyCode: $.ui.keyCode.UP } );
        }
        element.simulate( "keyup", { keyCode: $.ui.keyCode.UP } );
});

test( "numberFormat, number", function() {
        expect( 2 );
        var element = $( "#spin" ).val( 0 ).spinner({ numberFormat: "n" });
        equal( element.val(), "0.00", "formatted on init" );
        element.spinner( "stepUp" );
        equal( element.val(), "1.00", "formatted after step" );
});

test( "numberFormat, number, simple", function() {
        expect( 2 );
        var element = $( "#spin" ).val( 0 ).spinner({ numberFormat: "n0" });
        equal( element.val(), "0", "formatted on init" );
        element.spinner( "stepUp" );
        equal( element.val(), "1", "formatted after step" );
});

test( "numberFormat, currency", function() {
        expect( 2 );
        var element = $( "#spin" ).val( 0 ).spinner({ numberFormat: "C" });
        equal( element.val(), "$0.00", "formatted on init" );
        element.spinner( "stepUp" );
        equal( element.val(), "$1.00", "formatted after step" );
});

test( "numberFormat, change", function() {
        expect( 2 );
        var element = $( "#spin" ).val( 5 ).spinner({ numberFormat: "n1" });
        equal( element.val(), "5.0", "formatted on init" );
        element.spinner( "option", "numberFormat", "c" );
        equal( element.val(), "$5.00", "formatted after change" );
});

test( "culture, null", function() {
        expect( 2 );
        Globalize.culture( "ja-JP" );
        var element = $( "#spin" ).val( 0 ).spinner({ numberFormat: "C" });
        equal( element.val(), "¥0", "formatted on init" );
        element.spinner( "stepUp" );
        equal( element.val(), "¥1", "formatted after step" );

        // reset culture
        Globalize.culture( "default" );
});

test( "currency, ja-JP", function() {
        expect( 2 );
        var element = $( "#spin" ).val( 0 ).spinner({
                numberFormat: "C",
                culture: "ja-JP"
        });
        equal( element.val(), "¥0", "formatted on init" );
        element.spinner( "stepUp" );
        equal( element.val(), "¥1", "formatted after step" );
});

test( "currency, change", function() {
        expect( 2 );
        var element = $( "#spin" ).val( 5 ).spinner({
                numberFormat: "C",
                culture: "ja-JP"
        });
        equal( element.val(), "¥5", "formatted on init" );
        element.spinner( "option", "culture", "en" );
        equal( element.val(), "$5.00", "formatted after change" );
});

test( "max", function() {
        expect( 3 );
        var element = $( "#spin" ).val( 1000 ).spinner({ max: 100 });
        equal( element.val(), 1000, "value not constrained on init" );

        element.spinner( "value", 1000 );
        equal( element.val(), 100, "max constrained in value method" );

        element.val( 1000 ).blur();
        equal( element.val(), 1000, "max not constrained if manual entry" );
});

test( "max, string", function() {
        expect( 3 );
        var element = $( "#spin" )
                .val( 1000 )
                .spinner({
                        max: "$100.00",
                        numberFormat: "C",
                        culture: "en"
                });
        equal( element.val(), "$1,000.00", "value not constrained on init" );
        equal( element.spinner( "option", "max" ), 100, "option converted to number" );

        element.spinner( "value", 1000 );
        equal( element.val(), "$100.00", "max constrained in value method" );
});

test( "min", function() {
        expect( 3 );
        var element = $( "#spin" ).val( -1000 ).spinner({ min: -100 });
        equal( element.val(), -1000, "value not constrained on init" );

        element.spinner( "value", -1000 );
        equal( element.val(), -100, "min constrained in value method" );

        element.val( -1000 ).blur();
        equal( element.val(), -1000, "min not constrained if manual entry" );
});

test( "min, string", function() {
        expect( 3 );
        var element = $( "#spin" )
                .val( -1000 )
                .spinner({
                        min: "-$100.00",
                        numberFormat: "C",
                        culture: "en"
                });
        equal( element.val(), "($1,000.00)", "value not constrained on init" );
        equal( element.spinner( "option", "min" ), -100, "option converted to number" );

        element.spinner( "value", -1000 );
        equal( element.val(), "($100.00)", "min constrained in value method" );
});

test( "step, 2", function() {
        expect( 3 );
        var element = $( "#spin" ).val( 0 ).spinner({ step: 2 });

        element.spinner( "stepUp" );
        equal( element.val(), "2", "stepUp" );

        element.spinner( "value", "10.5" );
        equal( element.val(), "10", "value reset to 10" );

        element.val( "4.5" );
        element.spinner( "stepUp" );
        equal( element.val(), "6", "stepUp" );
});

test( "step, 0.7", function() {
        expect( 1 );
        var element = $("#spin").val( 0 ).spinner({
                step: 0.7
        });

        element.spinner( "stepUp" );
        equal( element.val(), "0.7", "stepUp" );
});

test( "step, string", function() {
        expect( 2 );
        var element = $("#spin").val( 0 ).spinner({
                step: "$0.70",
                numberFormat: "C",
                culture: "en"
        });

        equal( element.spinner( "option", "step" ), 0.7, "option converted to number" );

        element.spinner( "stepUp" );
        equal( element.val(), "$0.70", "stepUp" );
});

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