text: var vows = require("vows"),
      load = require("../load"),
      assert = require("../assert");
  
  var suite = vows.describe("d3.geo.bounds");
  
  suite.addBatch({
      "bounds": {
          topic: load("geo/bounds").expression("d3.geo.bounds"),
          "Feature": function (bounds) {
              assert.deepEqual(bounds({
                  type: "Feature",
                  geometry: {
                      type: "MultiPoint",
                      coordinates: [
                          [-123, 39],
                          [-122, 38]
                      ]
                  }
              }), [
                  [-123, 38],
                  [-122, 39]
              ]);
          },
          "FeatureCollection": function (bounds) {
              assert.deepEqual(bounds({
                  type: "FeatureCollection",
                  features: [
                      {
                          type: "Feature",
                          geometry: {
                              type: "Point",
                              coordinates: [-123, 39]
                          }
                      },
                      {
                          type: "Feature",
                          geometry: {
                              type: "Point",
                              coordinates: [-122, 38]
                          }
                      }
                  ]
              }), [
                  [-123, 38],
                  [-122, 39]
              ]);
          },
          "GeometryCollection": function (bounds) {
              assert.deepEqual(bounds({
                  type: "GeometryCollection",
                  geometries: [
                      {
                          type: "Point",
                          coordinates: [-123, 39]
                      },
                      {
                          type: "Point",
                          coordinates: [-122, 38]
                      }
                  ]
              }), [
                  [-123, 38],
                  [-122, 39]
              ]);
          },
          "LineString": {
              "simple": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "LineString",
                      coordinates: [
                          [-123, 39],
                          [-122, 38]
                      ]
                  }), [
                      [-123, 38],
                      [-122, 39]
                  ]);
              },
              "containing coincident points": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "LineString",
                      coordinates: [
                          [-123, 39],
                          [-122, 38],
                          [-122, 38]
                      ]
                  }), [
                      [-123, 38],
                      [-122, 39]
                  ]);
              },
              "meridian": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "LineString",
                      coordinates: [
                          [0, 0],
                          [0, 1],
                          [0, 60]
                      ]
                  }), [
                      [0, 0],
                      [0, 60]
                  ]);
              },
              "equator": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "LineString",
                      coordinates: [
                          [0, 0],
                          [1, 0],
                          [60, 0]
                      ]
                  }), [
                      [0, 0],
                      [60, 0]
                  ]);
              },
              "containing an inflection point": {
                  "in the Northern hemisphere": function (bounds) {
                      assert.inDelta(bounds({
                          type: "LineString",
                          coordinates: [
                              [-45, 60],
                              [45, 60]
                          ]
                      }), [
                          [-45, 60],
                          [45, 67.792345]
                      ], 1e-6);
                  },
                  "in the Southern hemisphere": function (bounds) {
                      assert.inDelta(bounds({
                          type: "LineString",
                          coordinates: [
                              [-45, -60],
                              [45, -60]
                          ]
                      }), [
                          [-45, -67.792345],
                          [45, -60]
                      ], 1e-6);
                  }
              }
          },
          "MultiLineString": function (bounds) {
              assert.deepEqual(bounds({
                  type: "MultiLineString",
                  coordinates: [
                      [
                          [-123, 39],
                          [-122, 38]
                      ]
                  ]
              }), [
                  [-123, 38],
                  [-122, 39]
              ]);
          },
          "MultiPoint": {
              "simple": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "MultiPoint",
                      coordinates: [
                          [-123, 39],
                          [-122, 38]
                      ]
                  }), [
                      [-123, 38],
                      [-122, 39]
                  ]);
              },
              "two points near antimeridian": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "MultiPoint",
                      coordinates: [
                          [-179, 39],
                          [179, 38]
                      ]
                  }), [
                      [179, 38],
                      [-179, 39]
                  ]);
              },
              "two points near antimeridian, two points near primary meridian": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "MultiPoint",
                      coordinates: [
                          [-179, 39],
                          [179, 38],
                          [-1, 0],
                          [1, 0]
                      ]
                  }), [
                      [-1, 0],
                      [-179, 39]
                  ]);
              },
              "two points near primary meridian, two points near antimeridian": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "MultiPoint",
                      coordinates: [
                          [-1, 0],
                          [1, 0],
                          [-179, 39],
                          [179, 38]
                      ]
                  }), [
                      [-1, 0],
                      [-179, 39]
                  ]);
              },
              "four mixed points near primary meridian and antimeridian": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "MultiPoint",
                      coordinates: [
                          [-1, 0],
                          [-179, 39],
                          [1, 0],
                          [179, 38]
                      ]
                  }), [
                      [-1, 0],
                      [-179, 39]
                  ]);
              },
              "three points near antimeridian": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "MultiPoint",
                      coordinates: [
                          [178, 38],
                          [179, 39],
                          [-179, 37]
                      ]
                  }), [
                      [178, 37],
                      [-179, 39]
                  ]);
              },
              "various points near antimeridian": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "MultiPoint",
                      coordinates: [
                          [-179, 39],
                          [-179, 38],
                          [178, 39],
                          [-178, 38]
                      ]
                  }), [
                      [178, 38],
                      [-178, 39]
                  ]);
              },
          },
          "MultiPolygon": function (bounds) {
              assert.inDelta(bounds({
                  type: "MultiPolygon",
                  coordinates: [
                      [
                          [
                              [-123, 39],
                              [-122, 39],
                              [-122, 38],
                              [-123, 39]
                          ],
                          [
                              [10, 20],
                              [20, 20],
                              [20, 10],
                              [10, 10],
                              [10, 20]
                          ]
                      ]
                  ]
              }), [
                  [-123, 10],
                  [20, 39.001067]
              ], 1e-6);
          },
          "Point": function (bounds) {
              assert.deepEqual(bounds({
                  type: "Point",
                  coordinates: [-123, 39]
              }), [
                  [-123, 39],
                  [-123, 39]
              ]);
          },
          "Polygon": {
              "simple": function (bounds) {
                  assert.inDelta(bounds({
                      type: "Polygon",
                      coordinates: [
                          [
                              [-123, 39],
                              [-122, 39],
                              [-122, 38],
                              [-123, 39]
                          ]
                      ]
                  }), [
                      [-123, 38],
                      [-122, 39.001067]
                  ], 1e-6);
              },
              "larger than a hemisphere": {
                  "small, counter-clockwise": function (bounds) {
                      assert.deepEqual(bounds({
                          type: "Polygon",
                          coordinates: [
                              [
                                  [0, 0],
                                  [10, 0],
                                  [10, 10],
                                  [0, 10],
                                  [0, 0]
                              ]
                          ]
                      }), [
                          [-180, -90],
                          [180, 90]
                      ]);
                  },
                  "large lat-lon rectangle": function (bounds) {
                      assert.inDelta(bounds({
                          type: "Polygon",
                          coordinates: [
                              [
                                  [-170, 80],
                                  [0, 80],
                                  [170, 80],
                                  [170, -80],
                                  [0, -80],
                                  [-170, -80],
                                  [-170, 80]
                              ]
                          ]
                      }), [
                          [-170, -89.119552],
                          [170, 89.119552]
                      ], 1e-6);
                  },
                  "South pole": function (bounds) {
                      assert.inDelta(bounds({
                          type: "Polygon",
                          coordinates: [
                              [
                                  [10, 80],
                                  [170, 80],
                                  [-170, 80],
                                  [-10, 80],
                                  [10, 80]
                              ]
                          ]
                      }), [
                          [-180, -90],
                          [180, 88.246216]
                      ], 1e-6);
                  },
                  "excluding both poles": function (bounds) {
                      assert.inDelta(bounds({
                          type: "Polygon",
                          coordinates: [
                              [
                                  [10, 80],
                                  [170, 80],
                                  [-170, 80],
                                  [-10, 80],
                                  [-10, 0],
                                  [-10, -80],
                                  [-170, -80],
                                  [170, -80],
                                  [10, -80],
                                  [10, 0],
                                  [10, 80]
                              ]
                          ]
                      }), [
                          [10, -88.246216],
                          [-10, 88.246216]
                      ], 1e-6);
                  }
              },
              "South pole": function (bounds) {
                  assert.deepEqual(bounds({
                      type: "Polygon",
                      coordinates: [
                          [
                              [-60, -80],
                              [60, -80],
                              [180, -80],
                              [-60, -80]
                          ]
                      ]
                  }), [
                      [-180, -90],
                      [180, -80]
                  ]);
              },
              "ring": function (bounds) {
                  assert.inDelta(bounds({
                      type: "Polygon",
                      coordinates: [
                          [
                              [-60, -80],
                              [60, -80],
                              [180, -80],
                              [-60, -80]
                          ],
                          [
                              [-60, -89],
                              [180, -89],
                              [60, -89],
                              [-60, -89]
                          ]
                      ]
                  }), [
                      [-180, -89.499961],
                      [180, -80]
                  ], 1e-6);
              }
          },
          "NestedCollection": function (bounds) {
              assert.deepEqual(bounds({
                  type: "FeatureCollection",
                  features: [
                      {
                          type: "Feature",
                          geometry: {
                              type: "GeometryCollection",
                              geometries: [
                                  {
                                      type: "Point",
                                      coordinates: [-120, 47]
                                  },
                                  {
                                      type: "Point",
                                      coordinates: [-119, 46]
                                  }
                              ]
                          }
                      }
                  ]
              }), [
                  [-120, 46],
                  [-119, 47]
              ]);
          },
          "null geometries": {
              "Feature": function (bounds) {
                  var b = bounds({type: "Feature", geometry: null});
                  assert.isNaN(b[0][0]);
                  assert.isNaN(b[0][1]);
                  assert.isNaN(b[1][0]);
                  assert.isNaN(b[1][1]);
              },
              "MultiPoint": function (bounds) {
                  var b = bounds({type: "MultiPoint", coordinates: []});
                  assert.isNaN(b[0][0]);
                  assert.isNaN(b[0][1]);
                  assert.isNaN(b[1][0]);
                  assert.isNaN(b[1][1]);
              },
              "MultiLineString": function (bounds) {
                  var b = bounds({type: "MultiLineString", coordinates: []});
                  assert.isNaN(b[0][0]);
                  assert.isNaN(b[0][1]);
                  assert.isNaN(b[1][0]);
                  assert.isNaN(b[1][1]);
              },
              "MultiPolygon": function (bounds) {
                  var b = bounds({type: "MultiPolygon", coordinates: []});
                  assert.isNaN(b[0][0]);
                  assert.isNaN(b[0][1]);
                  assert.isNaN(b[1][0]);
                  assert.isNaN(b[1][1]);
              }
          }
      }
  });
  
  suite.export(module);
  