more tests for the backtrack

test/bruteForceSpec.js

@@ -1,3 +1,5 @@
+
+
 Screw.Unit(function() {
 
     var default_extractor = function (obj) {
@@ -10,40 +12,45 @@ Screw.Unit(function() {
     describe("Brute Force", function () {
         it("Empty collection input returns empty result", function () {
             var result = bruteforce([], 100, default_extractor, percent);
-            expect(result).to(equal, []);
+            expect(result).to(contains_same_elements, []);
         });
 
         it("Value zero must return empty or zero list", function () {
             var result = bruteforce([{value: 100}], 0, default_extractor, percent);
-            expect(result).to(equal, []);
+            expect(result).to(contains_same_elements, []);
 
             var result = bruteforce([{value: 0}], 0, default_extractor, percent);
-            expect(result).to(equal, [[{value: 0}]]);
+            expect(result).to(contains_same_elements, [[{value: 0}]]);
         });
 
         it("Collection with one element that matches with value return this object", function () {
             var result = bruteforce([{value: 100}], 100, default_extractor, percent);
-            expect(result).to(equal, [[{value: 100}]]);
+            expect(result).to(contains_same_elements, [[{value: 100}]]);
         });
 
         it("Collection with two elements that one matches with value returns this element", function () {
             var result = bruteforce([{value: 100}, {value: 200}], 100, default_extractor, percent);
-            expect(result).to(equal, [[{value: 100}]]);
+            expect(result).to(contains_same_elements, [[{value: 100}]]);
         });
 
         it("Collection with two elements that one is smaller than value with value returns other element", function () {
             var result = bruteforce([{value: 200}, {value: 100}], 200, default_extractor, percent);
-            expect(result).to(equal, [[{value: 200}]]);
+            expect(result).to(contains_same_elements, [[{value: 200}]]);
         });
 
         it("Collection with two elements that fits value returns these two elements", function () {
             var result = bruteforce([{value: 100}, {value: 100}], 200, default_extractor, percent);
-            expect(result).to(equal, [[{value: 100}, {value: 100}]]);
+            expect(result).to(contains_same_elements, [[{value: 100}, {value: 100}]]);
+        });
+
+        it("Brings all possible solutions", function() {
+            var result = bruteforce([{value: 1}, {value: 2}, {value: 3}, {value: 4}, {value: 5}, {value: 6}], 6, default_extractor, percent);
+            expect(result).to(contains_same_elements, [[{value:6}], [{value:1},{value:5}], [{value:2},{value:4}], [{value:1},{value:3},{value:2}]]);
         });
 
         it("Big Test", function () {
             var result = bruteforce([{value: 100}, {value: 300}, {value: 200}, {value: 350}, {value: 120}, {value: 500}], 450, default_extractor, percent);
-            expect(result).to(equal, [[{value: 350}, {value: 100}]]);
+            expect(result).to(contains_same_elements, [[{value: 350}, {value: 100}]]);
         });
     });
 });

test/bruteForceSuite.html

@@ -13,6 +13,7 @@
         <script src="../lib/smoke.stub.js"></script>
 
         <script src="../bruteforce.js"></script>
+        <script src="matchers.js"></script>
         <script src="bruteForceSpec.js"></script>
 
         <link rel="stylesheet" href="../lib/screw.css">

test/matchers.js

@@ -0,0 +1,45 @@
+var contains_same_elements = {
+    index_of: function (element, list) {
+        var i;
+        for(i = 0; i < list.length; i++) {
+            if(element instanceof Array) {
+                if((list[i] instanceof Array) && this.list_equal(list[i], element)) {
+                    return i;
+                }
+            }
+            else if(Screw.Matchers.equal.match(element, list[i])) {
+                return i;
+            }
+        }
+        return -1;
+    },
+    remove: function (list, index) {
+        list[index] = list[list.length - 1];
+        list.pop();
+    },
+    list_equal: function (list1, list2) {
+        var copy_list2 = list2.slice(0, list2.length);
+        var i;
+        for(i = 0; i < list1.length; i++) {
+            var list1_item = list1[i];
+            var index_on_list2 = this.index_of(list1_item, copy_list2)
+            if(index_on_list2 == -1) {
+                return false;
+            }
+            this.remove(copy_list2, index_on_list2);
+        }
+        return copy_list2.length == 0;
+    },
+    match:
+        function(expected, actual) {
+	        if(expected.length != actual.length) {
+	            return false;
+	        }
+	        return this.list_equal(expected, actual);
+        },
+    failure_message: 
+        function (expected, actual, not) {
+            return "expected " + $.print(actual) + (not ? ' to not contain ' : ' to contain ') + $.print(expected);;
+        }
+};
+

test/matchersSpec.js

@@ -0,0 +1,25 @@
+
+
+Screw.Unit(function() {
+    describe("Collection Matcher", function() {
+        it("should match empty collections", function() {
+            expect([]).to(contains_same_elements, []);
+        });
+        it("should match collections of primitives in any order", function() {
+            expect([1,2,3,"hi","pokemon"]).to(contains_same_elements, ["pokemon", 3, 1, 2, "hi"]);
+        });
+        it("should not match collections of different size", function() {
+            expect([1,2,3,4,5,6]).to_not(contains_same_elements, [1,2,3]);
+            expect([1,2,3]).to_not(contains_same_elements, [1,2,3,4,5,6]);
+        });
+        it("should match collections with repetitions", function() {
+            expect([1,2,3,3,3,3]).to(contains_same_elements, [3,1,3,2,3,3]);
+            expect([1,2,3,3,3,3]).to_not(contains_same_elements, [3,1,3,2]);
+            expect([1,2,3,3,3,3]).to_not(contains_same_elements, [3,1,1,1,2,1]);
+        });
+        it("should match collections in any order of collections in any order", function() {
+            expect([[1,2],3,4,[5]]).to(contains_same_elements, [[5], 4, 3, [2,1]]);
+            expect([[1,2],3,4,[5]]).to_not(contains_same_elements, [5,4,3,2,1]);
+        });
+    });
+});

test/matchersSuite.html

@@ -0,0 +1,22 @@
+<html>
+    <head>
+        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+        <script src="../lib/jquery-1.2.6.js"></script>
+        <script src="../lib/jquery.fn.js"></script>
+        <script src="../lib/jquery.print.js"></script>
+        <script src="../lib/screw.builder.js"></script>
+        <script src="../lib/screw.matchers.js"></script>
+        <script src="../lib/screw.events.js"></script>
+        <script src="../lib/screw.behaviors.js"></script>
+        <script src="../lib/smoke.core.js"></script>
+        <script src="../lib/smoke.mock.js"></script>
+        <script src="../lib/smoke.stub.js"></script>
+
+        <script src="matchers.js"></script>
+        <script src="matchersSpec.js"></script>
+
+        <link rel="stylesheet" href="../lib/screw.css">
+    </head>
+    <body>
+    </body>
+</html>