← Back to branch summary

~bcsaller/juju-gui/charmFind

« back to all changes in this revision

Viewing changes to lib/d3/test/time/scale-test.js

  • Committer: kapil.foss at gmail
  • Date: 2012-07-13 18:45:59 UTC
  • Revision ID: kapil.foss@gmail.com-20120713184559-2xl7be17egsrz0c9
reshape

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/d3/test/time/scale-test.js
1
 
require("../env");
2
 
 
3
 
var vows = require("vows"),
4
 
    assert = require("assert"),
5
 
    time = require("./time"),
6
 
    local = time.local,
7
 
    utc = time.utc;
8
 
 
9
 
var suite = vows.describe("d3.time.scale");
10
 
 
11
 
suite.addBatch({
12
 
  "scale": {
13
 
    topic: function() {
14
 
      return d3.time.scale;
15
 
    },
16
 
 
17
 
    "copy": {
18
 
      "changes to the domain are isolated": function(scale) {
19
 
        var x = scale().domain([local(2009, 0, 1), local(2010, 0, 1)]), y = x.copy();
20
 
        x.domain([local(2010, 0, 1), local(2011, 0, 1)]);
21
 
        assert.deepEqual(y.domain(), [local(2009, 0, 1), local(2010, 0, 1)]);
22
 
        assert.equal(x(local(2010, 0, 1)), 0);
23
 
        assert.equal(y(local(2010, 0, 1)), 1);
24
 
        y.domain([local(2011, 0, 1), local(2012, 0, 1)]);
25
 
        assert.equal(x(local(2011, 0, 1)), 1);
26
 
        assert.equal(y(local(2011, 0, 1)), 0);
27
 
        assert.deepEqual(x.domain(), [local(2010, 0, 1), local(2011, 0, 1)]);
28
 
        assert.deepEqual(y.domain(), [local(2011, 0, 1), local(2012, 0, 1)]);
29
 
      },
30
 
      "changes to the range are isolated": function(scale) {
31
 
        var x = scale().domain([local(2009, 0, 1), local(2010, 0, 1)]), y = x.copy();
32
 
        x.range([1, 2]);
33
 
        assert.deepEqual(x.invert(1), local(2009, 0, 1));
34
 
        assert.deepEqual(y.invert(1), local(2010, 0, 1));
35
 
        assert.deepEqual(y.range(), [0, 1]);
36
 
        y.range([2, 3]);
37
 
        assert.deepEqual(x.invert(2), local(2010, 0, 1));
38
 
        assert.deepEqual(y.invert(2), local(2009, 0, 1));
39
 
        assert.deepEqual(x.range(), [1, 2]);
40
 
        assert.deepEqual(y.range(), [2, 3]);
41
 
      },
42
 
      "changes to the interpolator are isolated": function(scale) {
43
 
        var x = scale().domain([local(2009, 0, 1), local(2010, 0, 1)]).range(["red", "blue"]), y = x.copy();
44
 
        x.interpolate(d3.interpolateHsl);
45
 
        assert.equal(x(local(2009, 6, 1)), "#ff00fd");
46
 
        assert.equal(y(local(2009, 6, 1)), "#81007e");
47
 
        assert.equal(y.interpolate(), d3.interpolate);
48
 
      },
49
 
      "changes to clamping are isolated": function(scale) {
50
 
        var x = scale().domain([local(2009, 0, 1), local(2010, 0, 1)]).clamp(true), y = x.copy();
51
 
        x.clamp(false);
52
 
        assert.equal(x(local(2011, 0, 1)), 2);
53
 
        assert.equal(y(local(2011, 0, 1)), 1);
54
 
        assert.isTrue(y.clamp());
55
 
        y.clamp(false);
56
 
        assert.equal(x(local(2011, 0, 1)), 2);
57
 
        assert.equal(y(local(2011, 0, 1)), 2);
58
 
        assert.isFalse(x.clamp());
59
 
      }
60
 
    },
61
 
 
62
 
    "ticks": {
63
 
      "observes explicit tick interval": function(scale) {
64
 
        var x = scale().domain([local(2011, 0, 1, 12, 1, 0), local(2011, 0, 1, 12, 4, 4)]);
65
 
        assert.deepEqual(x.ticks(d3.time.minutes), [
66
 
          local(2011, 0, 1, 12, 1),
67
 
          local(2011, 0, 1, 12, 2),
68
 
          local(2011, 0, 1, 12, 3),
69
 
          local(2011, 0, 1, 12, 4)
70
 
        ]);
71
 
      },
72
 
      "observes explicit tick interval and step": function(scale) {
73
 
        var x = scale().domain([local(2011, 0, 1, 12, 0, 0), local(2011, 0, 1, 12, 33, 4)]);
74
 
        assert.deepEqual(x.ticks(d3.time.minutes, 10), [
75
 
          local(2011, 0, 1, 12, 0),
76
 
          local(2011, 0, 1, 12, 10),
77
 
          local(2011, 0, 1, 12, 20),
78
 
          local(2011, 0, 1, 12, 30)
79
 
        ]);
80
 
      },
81
 
      "generates sub-second ticks": function(scale) {
82
 
        var x = scale().domain([local(2011, 0, 1, 12, 0, 0), local(2011, 0, 1, 12, 0, 1)]);
83
 
        assert.deepEqual(x.ticks(4), [
84
 
          local(2011, 0, 1, 12, 0, 0,   0),
85
 
          local(2011, 0, 1, 12, 0, 0, 200),
86
 
          local(2011, 0, 1, 12, 0, 0, 400),
87
 
          local(2011, 0, 1, 12, 0, 0, 600),
88
 
          local(2011, 0, 1, 12, 0, 0, 800),
89
 
          local(2011, 0, 1, 12, 0, 1,   0)
90
 
        ]);
91
 
      },
92
 
      "generates 1-second ticks": function(scale) {
93
 
        var x = scale().domain([local(2011, 0, 1, 12, 0, 0), local(2011, 0, 1, 12, 0, 4)]);
94
 
        assert.deepEqual(x.ticks(4), [
95
 
          local(2011, 0, 1, 12, 0, 0),
96
 
          local(2011, 0, 1, 12, 0, 1),
97
 
          local(2011, 0, 1, 12, 0, 2),
98
 
          local(2011, 0, 1, 12, 0, 3),
99
 
          local(2011, 0, 1, 12, 0, 4)
100
 
        ]);
101
 
      },
102
 
      "generates 5-second ticks": function(scale) {
103
 
        var x = scale().domain([local(2011, 0, 1, 12, 0, 0), local(2011, 0, 1, 12, 0, 20)]);
104
 
        assert.deepEqual(x.ticks(4), [
105
 
          local(2011, 0, 1, 12, 0, 0),
106
 
          local(2011, 0, 1, 12, 0, 5),
107
 
          local(2011, 0, 1, 12, 0, 10),
108
 
          local(2011, 0, 1, 12, 0, 15),
109
 
          local(2011, 0, 1, 12, 0, 20)
110
 
        ]);
111
 
      },
112
 
      "generates 15-second ticks": function(scale) {
113
 
        var x = scale().domain([local(2011, 0, 1, 12, 0, 0), local(2011, 0, 1, 12, 0, 50)]);
114
 
        assert.deepEqual(x.ticks(4), [
115
 
          local(2011, 0, 1, 12, 0, 0),
116
 
          local(2011, 0, 1, 12, 0, 15),
117
 
          local(2011, 0, 1, 12, 0, 30),
118
 
          local(2011, 0, 1, 12, 0, 45)
119
 
        ]);
120
 
      },
121
 
      "generates 30-second ticks": function(scale) {
122
 
        var x = scale().domain([local(2011, 0, 1, 12, 0, 0), local(2011, 0, 1, 12, 1, 50)]);
123
 
        assert.deepEqual(x.ticks(4), [
124
 
          local(2011, 0, 1, 12, 0, 0),
125
 
          local(2011, 0, 1, 12, 0, 30),
126
 
          local(2011, 0, 1, 12, 1, 0),
127
 
          local(2011, 0, 1, 12, 1, 30)
128
 
        ]);
129
 
      },
130
 
      "generates 1-minute ticks": function(scale) {
131
 
        var x = scale().domain([local(2011, 0, 1, 12, 0, 27), local(2011, 0, 1, 12, 4, 12)]);
132
 
        assert.deepEqual(x.ticks(4), [
133
 
          local(2011, 0, 1, 12, 1),
134
 
          local(2011, 0, 1, 12, 2),
135
 
          local(2011, 0, 1, 12, 3),
136
 
          local(2011, 0, 1, 12, 4)
137
 
        ]);
138
 
      },
139
 
      "generates 5-minute ticks": function(scale) {
140
 
        var x = scale().domain([local(2011, 0, 1, 12, 3, 27), local(2011, 0, 1, 12, 21, 12)]);
141
 
        assert.deepEqual(x.ticks(4), [
142
 
          local(2011, 0, 1, 12, 5),
143
 
          local(2011, 0, 1, 12, 10),
144
 
          local(2011, 0, 1, 12, 15),
145
 
          local(2011, 0, 1, 12, 20)
146
 
        ]);
147
 
      },
148
 
      "generates 15-minute ticks": function(scale) {
149
 
        var x = scale().domain([local(2011, 0, 1, 12, 8, 27), local(2011, 0, 1, 13, 4, 12)]);
150
 
        assert.deepEqual(x.ticks(4), [
151
 
          local(2011, 0, 1, 12, 15),
152
 
          local(2011, 0, 1, 12, 30),
153
 
          local(2011, 0, 1, 12, 45),
154
 
          local(2011, 0, 1, 13, 0)
155
 
        ]);
156
 
      },
157
 
      "generates 30-minute ticks": function(scale) {
158
 
        var x = scale().domain([local(2011, 0, 1, 12, 28, 27), local(2011, 0, 1, 14, 4, 12)]);
159
 
        assert.deepEqual(x.ticks(4), [
160
 
          local(2011, 0, 1, 12, 30),
161
 
          local(2011, 0, 1, 13, 0),
162
 
          local(2011, 0, 1, 13, 30),
163
 
          local(2011, 0, 1, 14, 0)
164
 
        ]);
165
 
      },
166
 
      "generates 1-hour ticks": function(scale) {
167
 
        var x = scale().domain([local(2011, 0, 1, 12, 28, 27), local(2011, 0, 1, 16, 34, 12)]);
168
 
        assert.deepEqual(x.ticks(4), [
169
 
          local(2011, 0, 1, 13, 0),
170
 
          local(2011, 0, 1, 14, 0),
171
 
          local(2011, 0, 1, 15, 0),
172
 
          local(2011, 0, 1, 16, 0)
173
 
        ]);
174
 
      },
175
 
      "generates 3-hour ticks": function(scale) {
176
 
        var x = scale().domain([local(2011, 0, 1, 14, 28, 27), local(2011, 0, 2, 1, 34, 12)]);
177
 
        assert.deepEqual(x.ticks(4), [
178
 
          local(2011, 0, 1, 15, 0),
179
 
          local(2011, 0, 1, 18, 0),
180
 
          local(2011, 0, 1, 21, 0),
181
 
          local(2011, 0, 2, 0, 0)
182
 
        ]);
183
 
      },
184
 
      "generates 6-hour ticks": function(scale) {
185
 
        var x = scale().domain([local(2011, 0, 1, 16, 28, 27), local(2011, 0, 2, 14, 34, 12)]);
186
 
        assert.deepEqual(x.ticks(4), [
187
 
          local(2011, 0, 1, 18, 0),
188
 
          local(2011, 0, 2, 0, 0),
189
 
          local(2011, 0, 2, 6, 0),
190
 
          local(2011, 0, 2, 12, 0)
191
 
        ]);
192
 
      },
193
 
      "generates 12-hour ticks": function(scale) {
194
 
        var x = scale().domain([local(2011, 0, 1, 16, 28, 27), local(2011, 0, 3, 21, 34, 12)]);
195
 
        assert.deepEqual(x.ticks(4), [
196
 
          local(2011, 0, 2, 0, 0),
197
 
          local(2011, 0, 2, 12, 0),
198
 
          local(2011, 0, 3, 0, 0),
199
 
          local(2011, 0, 3, 12, 0)
200
 
        ]);
201
 
      },
202
 
      "generates 1-day ticks": function(scale) {
203
 
        var x = scale().domain([local(2011, 0, 1, 16, 28, 27), local(2011, 0, 5, 21, 34, 12)]);
204
 
        assert.deepEqual(x.ticks(4), [
205
 
          local(2011, 0, 2, 0, 0),
206
 
          local(2011, 0, 3, 0, 0),
207
 
          local(2011, 0, 4, 0, 0),
208
 
          local(2011, 0, 5, 0, 0)
209
 
        ]);
210
 
      },
211
 
      "generates 2-day ticks": function(scale) {
212
 
        var x = scale().domain([local(2011, 0, 2, 16, 28, 27), local(2011, 0, 9, 21, 34, 12)]);
213
 
        assert.deepEqual(x.ticks(4), [
214
 
          local(2011, 0, 3, 0, 0),
215
 
          local(2011, 0, 5, 0, 0),
216
 
          local(2011, 0, 7, 0, 0),
217
 
          local(2011, 0, 9, 0, 0)
218
 
        ]);
219
 
      },
220
 
      "generates 1-week ticks": function(scale) {
221
 
        var x = scale().domain([local(2011, 0, 1, 16, 28, 27), local(2011, 0, 23, 21, 34, 12)]);
222
 
        assert.deepEqual(x.ticks(4), [
223
 
          local(2011, 0, 2, 0, 0),
224
 
          local(2011, 0, 9, 0, 0),
225
 
          local(2011, 0, 16, 0, 0),
226
 
          local(2011, 0, 23, 0, 0)
227
 
        ]);
228
 
      },
229
 
      "generates 1-month ticks": function(scale) {
230
 
        var x = scale().domain([local(2011, 0, 18), local(2011, 4, 2)]);
231
 
        assert.deepEqual(x.ticks(4), [
232
 
          local(2011, 1, 1, 0, 0),
233
 
          local(2011, 2, 1, 0, 0),
234
 
          local(2011, 3, 1, 0, 0),
235
 
          local(2011, 4, 1, 0, 0)
236
 
        ]);
237
 
      },
238
 
      "generates 3-month ticks": function(scale) {
239
 
        var x = scale().domain([local(2010, 11, 18), local(2011, 10, 2)]);
240
 
        assert.deepEqual(x.ticks(4), [
241
 
          local(2011, 0, 1, 0, 0),
242
 
          local(2011, 3, 1, 0, 0),
243
 
          local(2011, 6, 1, 0, 0),
244
 
          local(2011, 9, 1, 0, 0)
245
 
        ]);
246
 
      },
247
 
      "generates 1-year ticks": function(scale) {
248
 
        var x = scale().domain([local(2010, 11, 18), local(2014, 2, 2)]);
249
 
        assert.deepEqual(x.ticks(4), [
250
 
          local(2011, 0, 1, 0, 0),
251
 
          local(2012, 0, 1, 0, 0),
252
 
          local(2013, 0, 1, 0, 0),
253
 
          local(2014, 0, 1, 0, 0)
254
 
        ]);
255
 
      },
256
 
      "generates multi-year ticks": function(scale) {
257
 
        var x = scale().domain([local(0, 11, 18), local(2014, 2, 2)]);
258
 
        assert.deepEqual(x.ticks(6), [
259
 
          local( 500, 0, 1, 0, 0),
260
 
          local(1000, 0, 1, 0, 0),
261
 
          local(1500, 0, 1, 0, 0),
262
 
          local(2000, 0, 1, 0, 0)
263
 
        ]);
264
 
      }
265
 
    },
266
 
 
267
 
    "tickFormat": {
268
 
      topic: function(scale) {
269
 
        return scale().tickFormat();
270
 
      },
271
 
      "formats year on New Year's": function(format) {
272
 
        assert.equal(format(local(2011, 0, 1)), "2011");
273
 
        assert.equal(format(local(2012, 0, 1)), "2012");
274
 
        assert.equal(format(local(2013, 0, 1)), "2013");
275
 
      },
276
 
      "formats month on the 1st of each month": function(format) {
277
 
        assert.equal(format(local(2011, 1, 1)), "February");
278
 
        assert.equal(format(local(2011, 2, 1)), "March");
279
 
        assert.equal(format(local(2011, 3, 1)), "April");
280
 
      },
281
 
      "formats week on Sunday midnight": function(format) {
282
 
        assert.equal(format(local(2011, 1, 6)), "Feb 06");
283
 
        assert.equal(format(local(2011, 1, 13)), "Feb 13");
284
 
        assert.equal(format(local(2011, 1, 20)), "Feb 20");
285
 
      },
286
 
      "formats date on midnight": function(format) {
287
 
        assert.equal(format(local(2011, 1, 2)), "Wed 02");
288
 
        assert.equal(format(local(2011, 1, 3)), "Thu 03");
289
 
        assert.equal(format(local(2011, 1, 4)), "Fri 04");
290
 
      },
291
 
      "formats hour on minute zero": function(format) {
292
 
        assert.equal(format(local(2011, 1, 2, 11)), "11 AM");
293
 
        assert.equal(format(local(2011, 1, 2, 12)), "12 PM");
294
 
        assert.equal(format(local(2011, 1, 2, 13)), "01 PM");
295
 
      },
296
 
      "formats minute on second zero": function(format) {
297
 
        assert.equal(format(local(2011, 1, 2, 11, 59)), "11:59");
298
 
        assert.equal(format(local(2011, 1, 2, 12,  1)), "12:01");
299
 
        assert.equal(format(local(2011, 1, 2, 12,  2)), "12:02");
300
 
      },
301
 
      "otherwise, formats second": function(format) {
302
 
        assert.equal(format(local(2011, 1, 2, 12,  1,  9)), ":09");
303
 
        assert.equal(format(local(2011, 1, 2, 12,  1, 10)), ":10");
304
 
        assert.equal(format(local(2011, 1, 2, 12,  1, 11)), ":11");
305
 
      }
306
 
    },
307
 
 
308
 
    "UTC": {
309
 
      topic: function(scale) {
310
 
        return scale.utc;
311
 
      },
312
 
 
313
 
      "ticks": {
314
 
        "observes explicit tick interval": function(scale) {
315
 
          var x = scale().domain([utc(2011, 0, 1, 12, 1, 0), utc(2011, 0, 1, 12, 4, 4)]);
316
 
          assert.deepEqual(x.ticks(d3.time.minutes), [
317
 
            utc(2011, 0, 1, 12, 1),
318
 
            utc(2011, 0, 1, 12, 2),
319
 
            utc(2011, 0, 1, 12, 3),
320
 
            utc(2011, 0, 1, 12, 4)
321
 
          ]);
322
 
        },
323
 
        "observes explicit tick interval and step": function(scale) {
324
 
          var x = scale().domain([utc(2011, 0, 1, 12, 0, 0), utc(2011, 0, 1, 12, 33, 4)]);
325
 
          assert.deepEqual(x.ticks(d3.time.minutes, 10), [
326
 
            utc(2011, 0, 1, 12, 0),
327
 
            utc(2011, 0, 1, 12, 10),
328
 
            utc(2011, 0, 1, 12, 20),
329
 
            utc(2011, 0, 1, 12, 30)
330
 
          ]);
331
 
        },
332
 
        "generates sub-second ticks": function(scale) {
333
 
          var x = scale().domain([utc(2011, 0, 1, 12, 0, 0), utc(2011, 0, 1, 12, 0, 1)]);
334
 
          assert.deepEqual(x.ticks(4), [
335
 
            utc(2011, 0, 1, 12, 0, 0,   0),
336
 
            utc(2011, 0, 1, 12, 0, 0, 200),
337
 
            utc(2011, 0, 1, 12, 0, 0, 400),
338
 
            utc(2011, 0, 1, 12, 0, 0, 600),
339
 
            utc(2011, 0, 1, 12, 0, 0, 800),
340
 
            utc(2011, 0, 1, 12, 0, 1,   0)
341
 
          ]);
342
 
        },
343
 
        "generates 1-second ticks": function(scale) {
344
 
          var x = scale().domain([utc(2011, 0, 1, 12, 0, 0), utc(2011, 0, 1, 12, 0, 4)]);
345
 
          assert.deepEqual(x.ticks(4), [
346
 
            utc(2011, 0, 1, 12, 0, 0),
347
 
            utc(2011, 0, 1, 12, 0, 1),
348
 
            utc(2011, 0, 1, 12, 0, 2),
349
 
            utc(2011, 0, 1, 12, 0, 3),
350
 
            utc(2011, 0, 1, 12, 0, 4)
351
 
          ]);
352
 
        },
353
 
        "generates 5-second ticks": function(scale) {
354
 
          var x = scale().domain([utc(2011, 0, 1, 12, 0, 0), utc(2011, 0, 1, 12, 0, 20)]);
355
 
          assert.deepEqual(x.ticks(4), [
356
 
            utc(2011, 0, 1, 12, 0, 0),
357
 
            utc(2011, 0, 1, 12, 0, 5),
358
 
            utc(2011, 0, 1, 12, 0, 10),
359
 
            utc(2011, 0, 1, 12, 0, 15),
360
 
            utc(2011, 0, 1, 12, 0, 20)
361
 
          ]);
362
 
        },
363
 
        "generates 15-second ticks": function(scale) {
364
 
          var x = scale().domain([utc(2011, 0, 1, 12, 0, 0), utc(2011, 0, 1, 12, 0, 50)]);
365
 
          assert.deepEqual(x.ticks(4), [
366
 
            utc(2011, 0, 1, 12, 0, 0),
367
 
            utc(2011, 0, 1, 12, 0, 15),
368
 
            utc(2011, 0, 1, 12, 0, 30),
369
 
            utc(2011, 0, 1, 12, 0, 45)
370
 
          ]);
371
 
        },
372
 
        "generates 30-second ticks": function(scale) {
373
 
          var x = scale().domain([utc(2011, 0, 1, 12, 0, 0), utc(2011, 0, 1, 12, 1, 50)]);
374
 
          assert.deepEqual(x.ticks(4), [
375
 
            utc(2011, 0, 1, 12, 0, 0),
376
 
            utc(2011, 0, 1, 12, 0, 30),
377
 
            utc(2011, 0, 1, 12, 1, 0),
378
 
            utc(2011, 0, 1, 12, 1, 30)
379
 
          ]);
380
 
        },
381
 
        "generates 1-minute ticks": function(scale) {
382
 
          var x = scale().domain([utc(2011, 0, 1, 12, 0, 27), utc(2011, 0, 1, 12, 4, 12)]);
383
 
          assert.deepEqual(x.ticks(4), [
384
 
            utc(2011, 0, 1, 12, 1),
385
 
            utc(2011, 0, 1, 12, 2),
386
 
            utc(2011, 0, 1, 12, 3),
387
 
            utc(2011, 0, 1, 12, 4)
388
 
          ]);
389
 
        },
390
 
        "generates 5-minute ticks": function(scale) {
391
 
          var x = scale().domain([utc(2011, 0, 1, 12, 3, 27), utc(2011, 0, 1, 12, 21, 12)]);
392
 
          assert.deepEqual(x.ticks(4), [
393
 
            utc(2011, 0, 1, 12, 5),
394
 
            utc(2011, 0, 1, 12, 10),
395
 
            utc(2011, 0, 1, 12, 15),
396
 
            utc(2011, 0, 1, 12, 20)
397
 
          ]);
398
 
        },
399
 
        "generates 15-minute ticks": function(scale) {
400
 
          var x = scale().domain([utc(2011, 0, 1, 12, 8, 27), utc(2011, 0, 1, 13, 4, 12)]);
401
 
          assert.deepEqual(x.ticks(4), [
402
 
            utc(2011, 0, 1, 12, 15),
403
 
            utc(2011, 0, 1, 12, 30),
404
 
            utc(2011, 0, 1, 12, 45),
405
 
            utc(2011, 0, 1, 13, 0)
406
 
          ]);
407
 
        },
408
 
        "generates 30-minute ticks": function(scale) {
409
 
          var x = scale().domain([utc(2011, 0, 1, 12, 28, 27), utc(2011, 0, 1, 14, 4, 12)]);
410
 
          assert.deepEqual(x.ticks(4), [
411
 
            utc(2011, 0, 1, 12, 30),
412
 
            utc(2011, 0, 1, 13, 0),
413
 
            utc(2011, 0, 1, 13, 30),
414
 
            utc(2011, 0, 1, 14, 0)
415
 
          ]);
416
 
        },
417
 
        "generates 1-hour ticks": function(scale) {
418
 
          var x = scale().domain([utc(2011, 0, 1, 12, 28, 27), utc(2011, 0, 1, 16, 34, 12)]);
419
 
          assert.deepEqual(x.ticks(4), [
420
 
            utc(2011, 0, 1, 13, 0),
421
 
            utc(2011, 0, 1, 14, 0),
422
 
            utc(2011, 0, 1, 15, 0),
423
 
            utc(2011, 0, 1, 16, 0)
424
 
          ]);
425
 
        },
426
 
        "generates 3-hour ticks": function(scale) {
427
 
          var x = scale().domain([utc(2011, 0, 1, 14, 28, 27), utc(2011, 0, 2, 1, 34, 12)]);
428
 
          assert.deepEqual(x.ticks(4), [
429
 
            utc(2011, 0, 1, 15, 0),
430
 
            utc(2011, 0, 1, 18, 0),
431
 
            utc(2011, 0, 1, 21, 0),
432
 
            utc(2011, 0, 2, 0, 0)
433
 
          ]);
434
 
        },
435
 
        "generates 6-hour ticks": function(scale) {
436
 
          var x = scale().domain([utc(2011, 0, 1, 16, 28, 27), utc(2011, 0, 2, 14, 34, 12)]);
437
 
          assert.deepEqual(x.ticks(4), [
438
 
            utc(2011, 0, 1, 18, 0),
439
 
            utc(2011, 0, 2, 0, 0),
440
 
            utc(2011, 0, 2, 6, 0),
441
 
            utc(2011, 0, 2, 12, 0)
442
 
          ]);
443
 
        },
444
 
        "generates 12-hour ticks": function(scale) {
445
 
          var x = scale().domain([utc(2011, 0, 1, 16, 28, 27), utc(2011, 0, 3, 21, 34, 12)]);
446
 
          assert.deepEqual(x.ticks(4), [
447
 
            utc(2011, 0, 2, 0, 0),
448
 
            utc(2011, 0, 2, 12, 0),
449
 
            utc(2011, 0, 3, 0, 0),
450
 
            utc(2011, 0, 3, 12, 0)
451
 
          ]);
452
 
        },
453
 
        "generates 1-day ticks": function(scale) {
454
 
          var x = scale().domain([utc(2011, 0, 1, 16, 28, 27), utc(2011, 0, 5, 21, 34, 12)]);
455
 
          assert.deepEqual(x.ticks(4), [
456
 
            utc(2011, 0, 2, 0, 0),
457
 
            utc(2011, 0, 3, 0, 0),
458
 
            utc(2011, 0, 4, 0, 0),
459
 
            utc(2011, 0, 5, 0, 0)
460
 
          ]);
461
 
        },
462
 
        "generates 2-day ticks": function(scale) {
463
 
          var x = scale().domain([utc(2011, 0, 2, 16, 28, 27), utc(2011, 0, 9, 21, 34, 12)]);
464
 
          assert.deepEqual(x.ticks(4), [
465
 
            utc(2011, 0, 3, 0, 0),
466
 
            utc(2011, 0, 5, 0, 0),
467
 
            utc(2011, 0, 7, 0, 0),
468
 
            utc(2011, 0, 9, 0, 0)
469
 
          ]);
470
 
        },
471
 
        "generates 1-week ticks": function(scale) {
472
 
          var x = scale().domain([utc(2011, 0, 1, 16, 28, 27), utc(2011, 0, 23, 21, 34, 12)]);
473
 
          assert.deepEqual(x.ticks(4), [
474
 
            utc(2011, 0, 2, 0, 0),
475
 
            utc(2011, 0, 9, 0, 0),
476
 
            utc(2011, 0, 16, 0, 0),
477
 
            utc(2011, 0, 23, 0, 0)
478
 
          ]);
479
 
        },
480
 
        "generates 1-month ticks": function(scale) {
481
 
          var x = scale().domain([utc(2011, 0, 18), utc(2011, 4, 2)]);
482
 
          assert.deepEqual(x.ticks(4), [
483
 
            utc(2011, 1, 1, 0, 0),
484
 
            utc(2011, 2, 1, 0, 0),
485
 
            utc(2011, 3, 1, 0, 0),
486
 
            utc(2011, 4, 1, 0, 0)
487
 
          ]);
488
 
        },
489
 
        "generates 3-month ticks": function(scale) {
490
 
          var x = scale().domain([utc(2010, 11, 18), utc(2011, 10, 2)]);
491
 
          assert.deepEqual(x.ticks(4), [
492
 
            utc(2011, 0, 1, 0, 0),
493
 
            utc(2011, 3, 1, 0, 0),
494
 
            utc(2011, 6, 1, 0, 0),
495
 
            utc(2011, 9, 1, 0, 0)
496
 
          ]);
497
 
        },
498
 
        "generates 1-year ticks": function(scale) {
499
 
          var x = scale().domain([utc(2010, 11, 18), utc(2014, 2, 2)]);
500
 
          assert.deepEqual(x.ticks(4), [
501
 
            utc(2011, 0, 1, 0, 0),
502
 
            utc(2012, 0, 1, 0, 0),
503
 
            utc(2013, 0, 1, 0, 0),
504
 
            utc(2014, 0, 1, 0, 0)
505
 
          ]);
506
 
        },
507
 
        "generates multi-year ticks": function(scale) {
508
 
          var x = scale().domain([utc(0, 11, 18), utc(2014, 2, 2)]);
509
 
          assert.deepEqual(x.ticks(6), [
510
 
            utc( 500, 0, 1, 0, 0),
511
 
            utc(1000, 0, 1, 0, 0),
512
 
            utc(1500, 0, 1, 0, 0),
513
 
            utc(2000, 0, 1, 0, 0)
514
 
          ]);
515
 
        }
516
 
      },
517
 
 
518
 
      "tickFormat": {
519
 
        topic: function(scale) {
520
 
          return scale().tickFormat();
521
 
        },
522
 
        "formats year on New Year's": function(format) {
523
 
          assert.equal(format(utc(2011, 0, 1)), "2011");
524
 
          assert.equal(format(utc(2012, 0, 1)), "2012");
525
 
          assert.equal(format(utc(2013, 0, 1)), "2013");
526
 
        },
527
 
        "formats month on the 1st of each month": function(format) {
528
 
          assert.equal(format(utc(2011, 1, 1)), "February");
529
 
          assert.equal(format(utc(2011, 2, 1)), "March");
530
 
          assert.equal(format(utc(2011, 3, 1)), "April");
531
 
        },
532
 
        "formats week on Sunday midnight": function(format) {
533
 
          assert.equal(format(utc(2011, 1, 6)), "Feb 06");
534
 
          assert.equal(format(utc(2011, 1, 13)), "Feb 13");
535
 
          assert.equal(format(utc(2011, 1, 20)), "Feb 20");
536
 
        },
537
 
        "formats date on midnight": function(format) {
538
 
          assert.equal(format(utc(2011, 1, 2)), "Wed 02");
539
 
          assert.equal(format(utc(2011, 1, 3)), "Thu 03");
540
 
          assert.equal(format(utc(2011, 1, 4)), "Fri 04");
541
 
        },
542
 
        "formats hour on minute zero": function(format) {
543
 
          assert.equal(format(utc(2011, 1, 2, 11)), "11 AM");
544
 
          assert.equal(format(utc(2011, 1, 2, 12)), "12 PM");
545
 
          assert.equal(format(utc(2011, 1, 2, 13)), "01 PM");
546
 
        },
547
 
        "formats minute on second zero": function(format) {
548
 
          assert.equal(format(utc(2011, 1, 2, 11, 59)), "11:59");
549
 
          assert.equal(format(utc(2011, 1, 2, 12,  1)), "12:01");
550
 
          assert.equal(format(utc(2011, 1, 2, 12,  2)), "12:02");
551
 
        },
552
 
        "formats second on millisecond zero": function(format) {
553
 
          assert.equal(format(utc(2011, 1, 2, 12,  1,  9)), ":09");
554
 
          assert.equal(format(utc(2011, 1, 2, 12,  1, 10)), ":10");
555
 
          assert.equal(format(utc(2011, 1, 2, 12,  1, 11)), ":11");
556
 
        },
557
 
        "otherwise, formats milliseconds": function(format) {
558
 
          assert.equal(format(utc(2011, 1, 2, 12,  1,  0,   9)), ".009");
559
 
          assert.equal(format(utc(2011, 1, 2, 12,  1,  0,  10)), ".010");
560
 
          assert.equal(format(utc(2011, 1, 2, 12,  1,  0,  11)), ".011");
561
 
        }
562
 
      }
563
 
    }
564
 
  }
565
 
});
566
 
 
567
 
suite.export(module);