Add MultiPoint and multipoint.

test/index.html

@@ -49,6 +49,7 @@
   <script type="text/javascript" src="spec/api/bounds.test.js"></script>
   <script type="text/javascript" src="spec/api/geom/geom.test.js"></script>
   <script type="text/javascript" src="spec/api/geom/point.test.js"></script>
+  <script type="text/javascript" src="spec/api/geom/multipoint.test.js"></script>
   <script type="text/javascript" src="spec/api/loc.test.js"></script>
   <script type="text/javascript" src="spec/api/map.test.js"></script>
   <script type="text/javascript" src="spec/api/projection.test.js"></script>
@@ -61,6 +62,7 @@
   <script type="text/javascript" src="spec/ol/Tile.test.js"></script>
   <script type="text/javascript" src="spec/ol/TileSet.test.js"></script>
   <script type="text/javascript" src="spec/ol/geom/Point.test.js"></script>
+  <script type="text/javascript" src="spec/ol/geom/MultiPoint.test.js"></script>
   <script type="text/javascript" src="spec/ol/layer/XYZ.test.js"></script>
   <script type="text/javascript" src="spec/ol/Feature.test.js"></script>
 

test/spec/api/geom/multipoint.test.js

@@ -0,0 +1,224 @@
+describe("ol.geom.multipoint", function() {  
+    var mp;
+    beforeEach(function() {
+        mp = ol.geom.multipoint([
+            {x:0, y:1},
+            {x:2, y:3}
+        ]);
+    });
+    
+    afterEach(function() {
+        mp = null;
+    });
+    describe("can construct instances without some points", function() {
+        it("works for the object notation of points", function(){
+            expect( mp ).toBeA( ol.geom.MultiPoint );
+        });
+        
+        it("works for the array notation of points", function(){
+            mp = ol.geom.multipoint([
+                [0, 1],
+                [2, 3]
+            ]);
+            
+            expect( mp ).toBeA( ol.geom.MultiPoint );
+        });
+        
+        it("works for real points", function(){
+            mp = ol.geom.multipoint([
+                ol.geom.point([0,1]),
+                ol.geom.point([2,3])
+            ]);
+            
+            expect( mp ).toBeA( ol.geom.MultiPoint );
+        });
+    });
+    
+    describe("can construct instances without any points", function() {
+        
+        it("works with an empty array", function(){
+            mp = ol.geom.multipoint([]);
+            
+            expect( mp ).toBeA( ol.geom.MultiPoint );
+        });
+        
+        it("works without arguments", function(){
+            mp = ol.geom.multipoint();
+            
+            expect( mp ).toBeA( ol.geom.MultiPoint );
+        });
+    });
+    
+    describe("the method 'add'", function() {
+        it("exists", function(){
+            expect( mp.add ).toBeA( Function );
+        });
+        
+        describe("can be used as setter", function(){
+            it("works with a single point specification and an index", function(){
+                var p = ol.geom.point([24,7]);
+                mp.add(p, 0);
+                
+                expect(mp.points().length).toBe(3);
+                
+                var firstPoint = mp.points()[0];
+                
+                expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' );
+            });
+            
+            it("works with point instance", function(){
+                mp = ol.geom.multipoint();
+                mp.add(ol.geom.point([24,7]));
+                expect(mp.points().length).toBe(1);
+                var firstPoint = mp.points()[0];
+                expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' );
+            });
+            
+            it("works with array specifications", function(){
+                mp = ol.geom.multipoint();
+                mp.add([24,7]);
+                expect(mp.points().length).toBe(1);
+                var firstPoint = mp.points()[0];
+                expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' );
+            });
+            
+            it("works with object specifications", function(){
+                mp = ol.geom.multipoint();
+                mp.add({x:24,y:7});
+                expect(mp.points().length).toBe(1);
+                var firstPoint = mp.points()[0];
+                expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' );
+            });
+            
+            it("the index is functional", function(){
+                var p = ol.geom.point([24,7]);
+                mp.add(p, 1);
+                
+                expect(mp.points().length).toBe(3);
+                
+                var firstPoint = mp.points()[0],  // untouched
+                    secondPoint = mp.points()[1], // this should be ours
+                    thirdPoint = mp.points()[2];  // shifted here
+                
+                expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '0,1' );
+                expect( secondPoint.x() + ',' + secondPoint.y() ).toBe( '24,7' );
+                expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '2,3' );
+            });
+            
+            it("the index is optional", function(){
+                var p = ol.geom.point([24,7]);
+                mp.add(p);
+                
+                expect(mp.points().length).toBe(3);
+                
+                var thirdPoint = mp.points()[2];
+                expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '24,7' );
+            });
+            
+            it("returns the multipoint instance", function(){
+                var p = ol.geom.point([24,7]);
+                var returned = mp.add(p);
+                
+                expect(returned).toBe(mp);
+            });
+        });
+    });
+    
+    describe("the method 'addAll'", function(){
+        it("exists", function(){
+            expect( mp.addAll ).toBeA( Function );
+        });
+        
+        describe("can be used as setter", function(){
+            
+            it("works with an array of point specifications and an index", function(){
+                var ps = [
+                    ol.geom.point([24,7]),
+                    ol.geom.point([7,11])
+                ];
+                mp.addAll(ps, 0);
+                
+                expect(mp.points().length).toBe(4);
+                
+                var firstPoint = mp.points()[0],
+                    secondPoint = mp.points()[1];
+                    
+                expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '24,7' );
+                expect( secondPoint.x() + ',' + secondPoint.y() ).toBe( '7,11' );
+            });
+            
+            it("the index is functional", function(){
+                var ps = [
+                    [24,7],
+                    {x:7, y:11}
+                ];
+                mp.addAll(ps, 1);
+                
+                expect(mp.points().length).toBe(4);
+                
+                var firstPoint = mp.points()[0],  // untouched
+                    secondPoint = mp.points()[1], // this should be ours
+                    thirdPoint = mp.points()[2],  // this should be ours
+                    fourthPoint = mp.points()[3];  // shifted here
+                
+                expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '0,1' );
+                expect( secondPoint.x() + ',' + secondPoint.y() ).toBe( '24,7' );
+                expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '7,11' );
+                expect( fourthPoint.x() + ',' + fourthPoint.y() ).toBe( '2,3' );
+            });
+            
+            it("the index is optional", function(){
+                var ps = [
+                    [24,7],
+                    {x:7, y:11}
+                ];
+                mp.addAll(ps);
+                
+                expect(mp.points().length).toBe(4);
+                
+                var thirdPoint = mp.points()[2],
+                    fourthPoint = mp.points()[3];
+                expect( thirdPoint.x() + ',' + thirdPoint.y() ).toBe( '24,7' );
+                expect( fourthPoint.x() + ',' + fourthPoint.y() ).toBe( '7,11' );
+            });
+            
+            it("returns the multipoint instance", function(){
+                var ps = [
+                    [24,7],
+                    {x:7, y:11}
+                ];
+                var returned = mp.addAll(ps);
+                
+                expect(returned).toBe(mp);
+            });
+        });
+    });
+    
+    
+    describe("the method 'remove'", function() {
+        it("exists", function(){
+            expect( mp.add ).toBeA( Function );
+        });
+        
+        it("works with a single point", function(){
+            var p = mp.points()[0];
+            mp.remove(p);
+            expect(mp.points().length).toBe(1);
+            var firstPoint = mp.points()[0];
+            expect( firstPoint.x() + ',' + firstPoint.y() ).toBe( '2,3' );
+        });
+        
+        it("works with an array of point specifications", function(){
+            var ps = [
+                mp.points()[1],
+                mp.points()[0]
+            ];
+            mp.remove(ps);
+            expect(mp.points().length).toBe(0);
+        });
+    });
+});
+
+
+
+

test/spec/ol/geom/MultiPoint.test.js

@@ -0,0 +1,106 @@
+describe("ol.geom.MultiPoint", function() {
+    var mp;
+    
+    beforeEach(function(){
+        mp = new ol.geom.MultiPoint([
+            new ol.geom.Point(10,20)
+        ]);
+    });
+    
+    afterEach(function(){
+        mp = null;
+    });
+    
+    it("constructs instances", function() {
+        expect( mp ).toBeA( ol.geom.MultiPoint );
+    });
+    
+    it("can construct instances without any points", function() {
+        // empty array
+        mp = new ol.geom.MultiPoint([]);
+        expect( mp ).toBeA( ol.geom.MultiPoint );
+        
+        // no argument at all
+        mp = new ol.geom.MultiPoint();
+        expect( mp ).toBeA( ol.geom.MultiPoint );
+    });
+    
+    it("inherits from ol.geom.Geometry", function() {
+        expect( mp ).toBeA( ol.geom.Geometry );
+    });
+    
+    it("has a working getter for points", function() {
+        
+        var points = mp.getPoints();
+        
+        expect( points ).toBeA( Array );
+        expect( points.length ).toBe( 1 );
+        expect( points[0] ).toBeA( ol.geom.Point );
+        
+        expect( points[0].getX() + ',' + points[0].getY()).toBe( '10,20' );
+        
+    });
+    
+    it("has a working setter for points", function() {
+        
+        mp.setPoints([
+            new ol.geom.Point(30,40),
+            new ol.geom.Point(50,60)
+        ]);
+        
+        var points = mp.getPoints();
+        
+        expect( points.length ).toBe( 2 );
+        expect( points[0] ).toBeA( ol.geom.Point );
+        expect( points[1] ).toBeA( ol.geom.Point );
+        
+        expect( points[0].getX() + ',' + points[0].getY()).toBe( '30,40' );
+        expect( points[1].getX() + ',' + points[1].getY()).toBe( '50,60' );
+        
+    });
+    
+    it("has a method to add points", function() {
+        
+        mp.addPoint(
+            new ol.geom.Point(30,40),
+            1
+        );
+        mp.addPoint(
+            new ol.geom.Point(50,60),
+            2
+        );
+        mp.addPoint(
+            new ol.geom.Point(-10,0),
+            0
+        );
+        
+        var points = mp.getPoints();
+        
+        expect( points.length ).toBe( 4 );
+        expect( points[0].getX() + ',' + points[0].getY()).toBe( '-10,0' );
+        expect( points[1].getX() + ',' + points[1].getY()).toBe( '10,20' );
+        expect( points[2].getX() + ',' + points[2].getY()).toBe( '30,40' );
+        expect( points[3].getX() + ',' + points[3].getY()).toBe( '50,60' );
+        
+    });
+    
+    it("has a method to remove points", function() {
+        mp.setPoints([
+            new ol.geom.Point(0,10),
+            new ol.geom.Point(10,20),
+            new ol.geom.Point(20,30),
+            new ol.geom.Point(30,40)
+        ]);
+        
+        var p = mp.getPoints()[2]; // 20,30;
+        
+        mp.removePoint( p );
+        
+        var points = mp.getPoints();
+        
+        expect( points.length ).toBe( 3 );
+        expect( points[0].getX() + ',' + points[0].getY()).toBe( '0,10' );
+        expect( points[1].getX() + ',' + points[1].getY()).toBe( '10,20' );
+        expect( points[2].getX() + ',' + points[2].getY()).toBe( '30,40' );
+    });     
+});