1 require("../env");

     2 require("../../d3");

     3 

     4 var vows = require("vows"),

     5     assert = require("assert");

     6 

     7 var suite = vows.describe("d3.format");

     8 

     9 suite.addBatch({

    10   "format": {

    11     topic: function() {

    12       return d3.format;

    13     },

    14     "returns a string": function(format) {

    15       assert.isString(format("d")(0));

    16     },

    17     "can zero fill": function(format) {

    18       var f = format("08d");

    19       assert.strictEqual(f(0), "00000000");

    20       assert.strictEqual(f(42), "00000042");

    21       assert.strictEqual(f(42000000), "42000000");

    22       assert.strictEqual(f(420000000), "420000000");

    23       assert.strictEqual(f(-4), "−0000004");

    24       assert.strictEqual(f(-42), "−0000042");

    25       assert.strictEqual(f(-4200000), "−4200000");

    26       assert.strictEqual(f(-42000000), "−42000000");

    27     },

    28     "can space fill": function(format) {

    29       var f = format("8d");

    30       assert.strictEqual(f(0), "       0");

    31       assert.strictEqual(f(42), "      42");

    32       assert.strictEqual(f(42000000), "42000000");

    33       assert.strictEqual(f(420000000), "420000000");

    34       assert.strictEqual(f(-4), "      −4");

    35       assert.strictEqual(f(-42), "     −42");

    36       assert.strictEqual(f(-4200000), "−4200000");

    37       assert.strictEqual(f(-42000000), "−42000000");

    38     },

    39     "can output fixed-point notation": function(format) {

    40       assert.strictEqual(format(".1f")(0.49), "0.5");

    41       assert.strictEqual(format(".2f")(0.449), "0.45");

    42       assert.strictEqual(format(".3f")(0.4449), "0.445");

    43       assert.strictEqual(format(".5f")(0.444449), "0.44445");

    44       assert.strictEqual(format(".1f")(100), "100.0");

    45       assert.strictEqual(format(".2f")(100), "100.00");

    46       assert.strictEqual(format(".3f")(100), "100.000");

    47       assert.strictEqual(format(".5f")(100), "100.00000");

    48     },

    49     "can output general notation": function(format) {

    50       assert.strictEqual(format(".1g")(0.049), "0.05");

    51       assert.strictEqual(format(".1g")(0.49), "0.5");

    52       assert.strictEqual(format(".2g")(0.449), "0.45");

    53       assert.strictEqual(format(".3g")(0.4449), "0.445");

    54       assert.strictEqual(format(".5g")(0.444449), "0.44445");

    55       assert.strictEqual(format(".1g")(100), "1e+2");

    56       assert.strictEqual(format(".2g")(100), "1.0e+2");

    57       assert.strictEqual(format(".3g")(100), "100");

    58       assert.strictEqual(format(".5g")(100), "100.00");

    59       assert.strictEqual(format(".5g")(100.2), "100.20");

    60       assert.strictEqual(format(".2g")(0.002), "0.0020");

    61     },

    62     "can output exponent notation ": function(format) {

    63       var f = format("e");

    64       assert.strictEqual(f(0), "0e+0");

    65       assert.strictEqual(f(42), "4.2e+1");

    66       assert.strictEqual(f(42000000), "4.2e+7");

    67       assert.strictEqual(f(420000000), "4.2e+8");

    68       assert.strictEqual(f(-4), "−4e+0");

    69       assert.strictEqual(f(-42), "−4.2e+1");

    70       assert.strictEqual(f(-4200000), "−4.2e+6");

    71       assert.strictEqual(f(-42000000), "−4.2e+7");

    72     },

    73     "can output SI prefix notation": function(format) {

    74       var f = format("s");

    75       assert.strictEqual(f(0), "0");

    76       assert.strictEqual(f(1), "1");

    77       assert.strictEqual(f(10), "10");

    78       assert.strictEqual(f(100), "100");

    79       assert.strictEqual(f(999.5), "999.5");

    80       assert.strictEqual(f(999500), "999.5k");

    81       assert.strictEqual(f(1000), "1k");

    82       assert.strictEqual(f(1500.5), "1.5005k");

    83       assert.strictEqual(f(.000001), "1μ");

    84     },

    85     "can output SI prefix notation with appropriate rounding": function(format) {

    86       var f = format(".3s");

    87       assert.strictEqual(f(0), "0.00");

    88       assert.strictEqual(f(1), "1.00");

    89       assert.strictEqual(f(10), "10.0");

    90       assert.strictEqual(f(100), "100");

    91       assert.strictEqual(f(999.5), "1.00k");

    92       assert.strictEqual(f(999500), "1.00M");

    93       assert.strictEqual(f(1000), "1.00k");

    94       assert.strictEqual(f(1500.5), "1.50k");

    95       assert.strictEqual(f(145500000), "146M");

    96       assert.strictEqual(f(145999999.999999347), "146M");

    97       assert.strictEqual(f(1e26), "100Y");

    98       assert.strictEqual(f(.000001), "1.00μ");

    99       assert.strictEqual(f(.009995), "0.0100");

   100       var f = format(".4s");

   101       assert.strictEqual(f(999.5), "999.5");

   102       assert.strictEqual(f(999500), "999.5k");

   103       assert.strictEqual(f(.009995), "9.995m");

   104     },

   105     "can output a percentage": function(format) {

   106       var f = format("%");

   107       assert.strictEqual(f(0), "0%");

   108       assert.strictEqual(f(.042), "4%");

   109       assert.strictEqual(f(.42), "42%");

   110       assert.strictEqual(f(4.2), "420%");

   111       assert.strictEqual(f(-.042), "−4%");

   112       assert.strictEqual(f(-.42), "−42%");

   113       assert.strictEqual(f(-4.2), "−420%");

   114     },

   115     "can output a percentage with rounding and sign": function(format) {

   116       var f = format("+.2p");

   117       assert.strictEqual(f(.00123), "+0.12%");

   118       assert.strictEqual(f(.0123), "+1.2%");

   119       assert.strictEqual(f(.123), "+12%");

   120       assert.strictEqual(f(1.23), "+120%");

   121       assert.strictEqual(f(-.00123), "−0.12%");

   122       assert.strictEqual(f(-.0123), "−1.2%");

   123       assert.strictEqual(f(-.123), "−12%");

   124       assert.strictEqual(f(-1.23), "−120%");

   125     },

   126     "can round to significant digits": function(format) {

   127       assert.strictEqual(format(".2r")(0), "0.0");

   128       assert.strictEqual(format(".1r")(0.049), "0.05");

   129       assert.strictEqual(format(".1r")(0.49), "0.5");

   130       assert.strictEqual(format(".2r")(0.449), "0.45");

   131       assert.strictEqual(format(".3r")(0.4449), "0.445");

   132       assert.strictEqual(format(".3r")(1.00), "1.00");

   133       assert.strictEqual(format(".3r")(0.9995), "1.00");

   134       assert.strictEqual(format(".5r")(0.444449), "0.44445");

   135       assert.strictEqual(format("r")(123.45), "123.45");

   136       assert.strictEqual(format(".1r")(123.45), "100");

   137       assert.strictEqual(format(".2r")(123.45), "120");

   138       assert.strictEqual(format(".3r")(123.45), "123");

   139       assert.strictEqual(format(".4r")(123.45), "123.5");

   140       assert.strictEqual(format(".5r")(123.45), "123.45");

   141       assert.strictEqual(format(".6r")(123.45), "123.450");

   142     },

   143     "can round very small numbers": function(format) {

   144       var f = format(".2r");

   145       assert.strictEqual(f(1e-22), "0.00000000000000000000");

   146     },

   147     "can group thousands": function(format) {

   148       var f = format(",d");

   149       assert.strictEqual(f(0), "0");

   150       assert.strictEqual(f(42), "42");

   151       assert.strictEqual(f(42000000), "42,000,000");

   152       assert.strictEqual(f(420000000), "420,000,000");

   153       assert.strictEqual(f(-4), "−4");

   154       assert.strictEqual(f(-42), "−42");

   155       assert.strictEqual(f(-4200000), "−4,200,000");

   156       assert.strictEqual(f(-42000000), "−42,000,000");

   157     },

   158     "can group thousands and zero fill": function(format) {

   159       assert.strictEqual(format("01,d")(0), "0");

   160       assert.strictEqual(format("01,d")(0), "0");

   161       assert.strictEqual(format("02,d")(0), "00");

   162       assert.strictEqual(format("03,d")(0), "000");

   163       assert.strictEqual(format("05,d")(0), "0,000");

   164       assert.strictEqual(format("08,d")(0), "0,000,000");

   165       assert.strictEqual(format("013,d")(0), "0,000,000,000");

   166       assert.strictEqual(format("021,d")(0), "0,000,000,000,000,000");

   167     },

   168     "can group thousands and zero fill with overflow": function(format) {

   169       assert.strictEqual(format("01,d")(1), "1");

   170       assert.strictEqual(format("01,d")(1), "1");

   171       assert.strictEqual(format("02,d")(12), "12");

   172       assert.strictEqual(format("03,d")(123), "123");

   173       assert.strictEqual(format("05,d")(12345), "12,345");

   174       assert.strictEqual(format("08,d")(12345678), "12,345,678");

   175       assert.strictEqual(format("013,d")(1234567890123), "1,234,567,890,123");

   176     },

   177     "can group thousands and space fill": function(format) {

   178       assert.strictEqual(format("1,d")(0), "0");

   179       assert.strictEqual(format("1,d")(0), "0");

   180       assert.strictEqual(format("2,d")(0), " 0");

   181       assert.strictEqual(format("3,d")(0), "  0");

   182       assert.strictEqual(format("5,d")(0), "    0");

   183       assert.strictEqual(format("8,d")(0), "       0");

   184       assert.strictEqual(format("13,d")(0), "            0");

   185       assert.strictEqual(format("21,d")(0), "                    0");

   186     },

   187     "can group thousands and space fill with overflow": function(format) {

   188       assert.strictEqual(format("1,d")(1), "1");

   189       assert.strictEqual(format("1,d")(1), "1");

   190       assert.strictEqual(format("2,d")(12), "12");

   191       assert.strictEqual(format("3,d")(123), "123");

   192       assert.strictEqual(format("5,d")(12345), "12,345");

   193       assert.strictEqual(format("8,d")(12345678), "12,345,678");

   194       assert.strictEqual(format("13,d")(1234567890123), "1,234,567,890,123");

   195     },

   196     "can group thousands with general notation": function(format) {

   197       var f = format(",g");

   198       assert.strictEqual(f(0), "0");

   199       assert.strictEqual(f(42), "42");

   200       assert.strictEqual(f(42000000), "42,000,000");

   201       assert.strictEqual(f(420000000), "420,000,000");

   202       assert.strictEqual(f(-4), "−4");

   203       assert.strictEqual(f(-42), "−42");

   204       assert.strictEqual(f(-4200000), "−4,200,000");

   205       assert.strictEqual(f(-42000000), "−42,000,000");

   206     },

   207     "can group thousands, space fill, and round to significant digits": function(format) {

   208       assert.strictEqual(format("10,.1f")(123456.49), " 123,456.5");

   209       assert.strictEqual(format("10,.2f")(1234567.449), "1,234,567.45");

   210       assert.strictEqual(format("10,.3f")(12345678.4449), "12,345,678.445");

   211       assert.strictEqual(format("10,.5f")(123456789.444449), "123,456,789.44445");

   212       assert.strictEqual(format("10,.1f")(123456), " 123,456.0");

   213       assert.strictEqual(format("10,.2f")(1234567), "1,234,567.00");

   214       assert.strictEqual(format("10,.3f")(12345678), "12,345,678.000");

   215       assert.strictEqual(format("10,.5f")(123456789), "123,456,789.00000");

   216     },

   217     "can display integers in fixed-point notation": function(format) {

   218       assert.strictEqual(format("f")(42), "42");

   219     },

   220     "will not display non-integers in integer format": function(format) {

   221       assert.strictEqual(format("d")(4.2), "");

   222     },

   223     "supports \"n\" as an alias for \",g\"": function(format) {

   224       var f = format("n");

   225       assert.strictEqual(f(.0042), "0.0042");

   226       assert.strictEqual(f(.42), "0.42");

   227       assert.strictEqual(f(0), "0");

   228       assert.strictEqual(f(42), "42");

   229       assert.strictEqual(f(42000000), "42,000,000");

   230       assert.strictEqual(f(420000000), "420,000,000");

   231       assert.strictEqual(f(-4), "−4");

   232       assert.strictEqual(f(-42), "−42");

   233       assert.strictEqual(f(-4200000), "−4,200,000");

   234       assert.strictEqual(f(-42000000), "−42,000,000");

   235     }

   236   }

   237 });

   238 

   239 suite.export(module);