Improved test coverage

CHANGES.md

@@ -7,7 +7,7 @@ Beta Releases
 ### b6 - TBA
 
 * Breaking changes:
-    * TBA
+    * Changed Tipsify.tipsify and Tipsify.calculateACMR to accept an object literal instead of three separate arguments. Supplying a maximum index and cache size is now optional.
 * TBA
 
 ### b5 - 05/15/2012

Source/Core/Cartesian3.js

@@ -280,11 +280,11 @@ define(['./Cartesian2'], function(Cartesian2) {
      * Returns the angle, in radians, between this Cartesian and the Cartesian passed in.
      *
      * @memberof Cartesian3
-     * @param {Cartesian3} scalar The Cartesian used to compute the angle.
+     * @param {Cartesian3} cartesian The Cartesian used to compute the angle.
      * @return {Number} The angle between the two Cartesians.
      */
-    Cartesian3.prototype.angleBetween = function(Cartesian) {
-        var c = Cartesian3.clone(Cartesian);
+    Cartesian3.prototype.angleBetween = function(cartesian) {
+        var c = Cartesian3.clone(cartesian);
         return Math.acos(this.normalize().dot(c.normalize()));
     };
 

Source/Core/MeshFilters.js

@@ -301,7 +301,9 @@ define([
                             maximumIndex = indices[j];
                         }
                     }
-                    indexLists[i].values = Tipsify.tipsify(indices, maximumIndex, cacheCapacity || 24);
+                    indexLists[i].values = Tipsify.tipsify({indices : indices,
+                                                            maximumIndex : maximumIndex,
+                                                            cacheSize : cacheCapacity});
                 }
             }
         }

Source/Core/Tipsify.js

@@ -19,14 +19,14 @@ define(['./DeveloperError'], function(DeveloperError) {
     /**
      * Calculates the average cache miss ratio (ACMR) for a given set of indices.
      *
-     * @param {Array} indices Lists triads of numbers corresponding to the indices of the vertices
+     * @param {Array} description.indices Lists triads of numbers corresponding to the indices of the vertices
      *                        in the vertex buffer that define the mesh's triangles.
-     * @param {Number} maximumIndex The maximum value of the elements in <code>indices</code>.
-     * @param {Number} cacheSize The number of vertices that can be stored in the cache at any one time.
+     * @param {Number} [description.maximumIndex] The maximum value of the elements in <code>args.indices</code>.
+     *                                     If not supplied, this value will be computed.
+     * @param {Number} [description.cacheSize=24] The number of vertices that can be stored in the cache at any one time.
      *
      * @exception {DeveloperError} indices is required.
      * @exception {DeveloperError} indices length must be a multiple of three.
-     * @exception {DeveloperError} maximumIndex must be greater than zero.
      * @exception {DeveloperError} cacheSize must be greater than two.
      *
      * @return {Number} The average cache miss ratio (ACMR).
@@ -37,7 +37,12 @@ define(['./DeveloperError'], function(DeveloperError) {
      * var cacheSize = 3;
      * var acmr = Tipsify.calculateACMR(indices, maxIndex, cacheSize);
      */
-    Tipsify.calculateACMR = function(indices, maximumIndex, cacheSize) {
+    Tipsify.calculateACMR = function(description) {
+        description = description || {};
+        var indices = description.indices;
+        var maximumIndex = description.maximumIndex;
+        var cacheSize = description.cacheSize || 24;
+
         if (!indices) {
             throw new DeveloperError("indices is required.", "indices");
         }
@@ -54,6 +59,20 @@ define(['./DeveloperError'], function(DeveloperError) {
             throw new DeveloperError("cacheSize must be greater than two.", "cachSize");
         }
 
+        // Compute the maximumIndex if not given
+        if(!maximumIndex) {
+            maximumIndex = 0;
+            var currentIndex = 0;
+            var intoIndices = indices[currentIndex];
+            while (currentIndex < numIndices) {
+                if (intoIndices > maximumIndex) {
+                    maximumIndex = intoIndices;
+                }
+                ++currentIndex;
+                intoIndices = indices[currentIndex];
+            }
+        }
+
         // Vertex time stamps
         var vertexTimeStamps = [];
         for ( var i = 0; i < maximumIndex + 1; i++) {
@@ -75,14 +94,14 @@ define(['./DeveloperError'], function(DeveloperError) {
     /**
      * Optimizes triangles for the post-vertex shader cache.
      *
-     * @param {Array} indices Lists triads of numbers corresponding to the indices of the vertices
+     * @param {Array} description.indices Lists triads of numbers corresponding to the indices of the vertices
      *                        in the vertex buffer that define the mesh's triangles.
-     * @param {Number} maximumIndex The maximum value of the elements in <code>indices</code>.
-     * @param {Number} cacheSize The number of vertices that can be stored in the cache at any one time.
+     * @param {Number} [description.maximumIndex] The maximum value of the elements in <code>args.indices</code>.
+     *                                     If not supplied, this value will be computed.
+     * @param {Number} [description.cacheSize=24] The number of vertices that can be stored in the cache at any one time.
      *
      * @exception {DeveloperError} indices is required.
      * @exception {DeveloperError} indices length must be a multiple of three.
-     * @exception {DeveloperError} maximumIndex must be greater than zero.
      * @exception {DeveloperError} cacheSize must be greater than two.
      *
      * @return {Array} A list of the input indices in an optimized order.
@@ -93,7 +112,12 @@ define(['./DeveloperError'], function(DeveloperError) {
      * var cacheSize = 3;
      * var reorderedIndices = Tipsify.tipsify(indices, maxIndex, cacheSize);
      */
-    Tipsify.tipsify = function(indices, maximumIndex, cacheSize) {
+    Tipsify.tipsify = function(description) {
+        description = description || {};
+        var indices = description.indices;
+        var maximumIndex = description.maximumIndex;
+        var cacheSize = description.cacheSize || 24;
+
         var cursor;
 
         function skipDeadEnd(vertices, deadEnd, indices, maximumIndexPlusOne) {
@@ -162,7 +186,7 @@ define(['./DeveloperError'], function(DeveloperError) {
         var currentIndex = 0;
         var intoIndices = indices[currentIndex];
         var endIndex = numIndices;
-        if (maximumIndex !== -1) {
+        if (maximumIndex) {
             maximumIndexPlusOne = maximumIndex + 1;
         } else {
             while (currentIndex < endIndex) {

Source/Renderer/TextureAtlas.js

@@ -172,14 +172,6 @@ define([
         return numTextureCoordinates;
     };
 
-    /**
-     * DOC_TBA
-     * @memberof TextureAtlas
-     */
-    TextureAtlas.prototype.getContext = function() {
-        return this._context;
-    };
-
     /**
      * DOC_TBA
      * @memberof TextureAtlas

Specs/Core/AxisAlignedBoundingBoxSpec.js

@@ -20,17 +20,17 @@ defineSuite([
 
     it("computes the minimum", function() {
         var box = new AxisAlignedBoundingBox(positions);
-        expect(box.minimum.equals(new Cartesian3(-3, -3, -3))).toBeTruthy();
+        expect(box.minimum.equals(new Cartesian3(-3, -3, -3))).toEqual(true);
     });
 
     it("computes the maximum", function() {
         var box = new AxisAlignedBoundingBox(positions);
-        expect(box.maximum.equals(new Cartesian3(3, 3, 3))).toBeTruthy();
+        expect(box.maximum.equals(new Cartesian3(3, 3, 3))).toEqual(true);
     });
 
     it("computes a center", function() {
         var box = new AxisAlignedBoundingBox(positions);
-        expect(box.center.equalsEpsilon(Cartesian3.ZERO, Math.EPSILON14)).toBeTruthy();
+        expect(box.center.equalsEpsilon(Cartesian3.ZERO, Math.EPSILON14)).toEqual(true);
     });
 
     it("computes the bounding box for a single position", function() {
@@ -40,9 +40,9 @@ defineSuite([
             z : 3
         }]);
 
-        expect(box.minimum.equals(new Cartesian3(1, 2, 3))).toBeTruthy();
-        expect(box.maximum.equals(new Cartesian3(1, 2, 3))).toBeTruthy();
-        expect(box.center.equals(new Cartesian3(1, 2, 3))).toBeTruthy();
+        expect(box.minimum.equals(new Cartesian3(1, 2, 3))).toEqual(true);
+        expect(box.maximum.equals(new Cartesian3(1, 2, 3))).toEqual(true);
+        expect(box.center.equals(new Cartesian3(1, 2, 3))).toEqual(true);
     });
 
     it("has undefined properties with positions of length zero", function() {

Specs/Core/AxisAlignedBoundingRectangleSpec.js

@@ -20,17 +20,17 @@ defineSuite([
 
     it("computes the minimum", function() {
         var rectangle = new AxisAlignedBoundingRectangle(positions);
-        expect(rectangle.minimum.equals(new Cartesian2(-3, -3))).toBeTruthy();
+        expect(rectangle.minimum.equals(new Cartesian2(-3, -3))).toEqual(true);
     });
 
     it("computes the maximum", function() {
         var rectangle = new AxisAlignedBoundingRectangle(positions);
-        expect(rectangle.maximum.equals(new Cartesian2(3, 3))).toBeTruthy();
+        expect(rectangle.maximum.equals(new Cartesian2(3, 3))).toEqual(true);
     });
 
     it("computes the center", function() {
         var rectangle = new AxisAlignedBoundingRectangle(positions);
-        expect(rectangle.center.equalsEpsilon(Cartesian2.ZERO, Math.EPSILON14)).toBeTruthy();
+        expect(rectangle.center.equalsEpsilon(Cartesian2.ZERO, Math.EPSILON14)).toEqual(true);
     });
 
     it("computes the bounding rectangle for a single position", function() {
@@ -39,9 +39,9 @@ defineSuite([
             y : 2
         }]);
 
-        expect(rectangle.minimum.equals(new Cartesian2(1, 2))).toBeTruthy();
-        expect(rectangle.maximum.equals(new Cartesian2(1, 2))).toBeTruthy();
-        expect(rectangle.center.equals(new Cartesian2(1, 2))).toBeTruthy();
+        expect(rectangle.minimum.equals(new Cartesian2(1, 2))).toEqual(true);
+        expect(rectangle.maximum.equals(new Cartesian2(1, 2))).toEqual(true);
+        expect(rectangle.center.equals(new Cartesian2(1, 2))).toEqual(true);
     });
 
     it("has undefined properties with positions of length zero", function() {

Specs/Core/BoundingSphereSpec.js

@@ -30,14 +30,14 @@ defineSuite([
 
     it("can be constructed using a point and a radius", function() {
         var sphere = new BoundingSphere(new Cartesian3(0, 0, 0), 1);
-        expect(sphere.center.equals(Cartesian3.ZERO)).toBeTruthy();
+        expect(sphere.center.equals(Cartesian3.ZERO)).toEqual(true);
         expect(sphere.radius).toEqual(1);
     });
 
     it("has a center", function() {
         var sphere = new BoundingSphere(getPositions());
         var center = sphere.center;
-        expect(center.equalsEpsilon(Cartesian3.ZERO, CesiumMath.EPSILON14)).toBeTruthy();
+        expect(center.equalsEpsilon(Cartesian3.ZERO, CesiumMath.EPSILON14)).toEqual(true);
     });
 
     it("has a radius", function() {
@@ -59,9 +59,9 @@ defineSuite([
         var numPositions = positions.length;
         for ( var i = 0; i < numPositions; i++) {
             var currentPos = positions[i];
-            expect(currentPos.x <= max.x && currentPos.x >= min.x).toBeTruthy();
-            expect(currentPos.y <= max.y && currentPos.y >= min.y).toBeTruthy();
-            expect(currentPos.z <= max.z && currentPos.z >= min.z).toBeTruthy();
+            expect(currentPos.x <= max.x && currentPos.x >= min.x).toEqual(true);
+            expect(currentPos.y <= max.y && currentPos.y >= min.y).toEqual(true);
+            expect(currentPos.z <= max.z && currentPos.z >= min.z).toEqual(true);
         }
     });
 
@@ -79,9 +79,9 @@ defineSuite([
         var numPositions = positions.length;
         for ( var i = 0; i < numPositions; i++) {
             var currentPos = positions[i];
-            expect(currentPos.x <= max.x && currentPos.x >= min.x).toBeTruthy();
-            expect(currentPos.y <= max.y && currentPos.y >= min.y).toBeTruthy();
-            expect(currentPos.z <= max.z && currentPos.z >= min.z).toBeTruthy();
+            expect(currentPos.x <= max.x && currentPos.x >= min.x).toEqual(true);
+            expect(currentPos.y <= max.y && currentPos.y >= min.y).toEqual(true);
+            expect(currentPos.z <= max.z && currentPos.z >= min.z).toEqual(true);
         }
     });
 });

Specs/Core/BoxTessellatorSpec.js

@@ -24,4 +24,13 @@ defineSuite([
         expect(m.attributes.position.values.length).toEqual(8 * 3);
         expect(m.indexLists[0].values.length).toEqual(12 * 3);
     });
+
+    it("compute2", function() {
+        expect(function() {
+            return BoxTessellator.compute({
+                minimumCorner : new Cartesian3(0, 0, 0),
+                maximumCorner : new Cartesian3(1, 1, 1)
+            });
+        }).not.toThrow();
+    });
 });

Specs/Core/CachePoliciesSpec.js

@@ -63,7 +63,7 @@ defineSuite([
             }
 
             // check that nothing was removed
-            expect(lastRemoved === null).toBeTruthy();
+            expect(lastRemoved === null).toEqual(true);
         });
 
         it("miss replaces lru", function() {

Specs/Core/CacheSpec.js

@@ -111,29 +111,44 @@ defineSuite([
             n : 13,
             key : "13"
         };
-        expect(cache.remove(thirteenth)).toBeFalsy();
+        expect(cache.remove(thirteenth)).toEqual(false);
 
         expect(cache.find(thirteenth).fibonacciNumber).toEqual(233);
         expect(cache.find(thirteenth).timesHit).toEqual(1);
-        expect(cache.remove(thirteenth)).toBeTruthy();
+        expect(cache.remove(thirteenth)).toEqual(true);
         expect(cache.find(thirteenth).timesHit).toBeFalsy();
         expect(cache.remove({
             n : 14,
             key : "14"
-        })).toBeFalsy();
+        })).toEqual(false);
     });
 
     it("remove returns false with no key", function() {
         var result = cache.remove();
-        expect(result).toBeFalsy();
-     });
+        expect(result).toEqual(false);
+    });
+
+    it("remove returns false with null key", function() {
+        var result = cache.remove({"key": null});
+        expect(result).toEqual(false);
+    });
 
     it("destroy", function() {
         cache = cache && cache.destroy();
         expect(cache).toBeUndefined();
     });
 
+    it("destroys cache with keys", function() {
+        var tenth = {
+            n : 10,
+            key : "10"
+        };
+        cache.find(tenth);
+        cache = cache && cache.destroy();
+        expect(cache).toBeUndefined();
+    });
+
     it("isDestroyed returns false", function() {
-       expect(cache.isDestroyed()).toBeFalsy();
+       expect(cache.isDestroyed()).toEqual(false);
     });
 });