jQuery Forum

Actually I think I found a much simpler patch to QUnit.equiv that shows how to break it in the browser.  The problem occurs when ever there is a circular reference that is reached before a property that proves unequivalence.  Here is the test that breaks QUnit by producing a stack overflow.

test('object with references to self wont loop', function(){
    var circularA = {
        abc:null
    }, circularB = {
        abc:null
    };
    circularA.abc = circularA;
    circularB.abc = circularB;
    equals(QUnit.equiv(circularA, circularB), true, "Should not repeat test on object (ambigous test)");
   
    circularA.def = 1;
    circularB.def = 1;
    equals(QUnit.equiv(circularA, circularB), true, "Should not repeat test on object (ambigous test)");
   
    circularA.def = 1;
    circularB.def = 0;
    equals(QUnit.equiv(circularA, circularB), false, "Should not repeat test on object (unambigous test)");
});

The patch is just to track references to objects and not retest objects.

Here is a patch:

diff --git a/qunit/qunit.js b/qunit/qunit.js
index f270414..f745000 100644
--- a/qunit/qunit.js
+++ b/qunit/qunit.js
@@ -679,6 +679,7 @@ QUnit.equiv = function () {
 
     var innerEquiv; // the real equiv function
     var callers = []; // stack to decide between skip/abort functions
+    var parents = []; // stack to avoiding loops from circular referencing
 
 
     // Determine what is o.
@@ -809,7 +810,7 @@ QUnit.equiv = function () {
             },
 
             "object": function (b, a) {
-                var i;
+                var i, j, loop;
                 var eq = true; // unless we can proove it
                 var aProperties = [], bProperties = []; // collection of strings
 
@@ -820,18 +821,24 @@ QUnit.equiv = function () {
 
                 // stack constructor before traversing properties
                 callers.push(a.constructor);
-
+                parents.push(a);
+               
                 for (i in a) { // be strict: don't ensures hasOwnProperty and go deep
-
+                    loop = false;
+                    for(j=0;j<parents.length;j++){
+                        if(parents[j] === a[i])
+                            loop = true; //don't go down the same path twice
+                    }
                     aProperties.push(i); // collect a's properties
 
-                    if ( ! innerEquiv(a[i], b[i])) {
+                    if (!loop && !innerEquiv(a[i], b[i])) {
                         eq = false;
                         break;
                     }
                 }
 
                 callers.pop(); // unstack, we are done
+                parents.pop();
 
                 for (i in b) {
                     bProperties.push(i); // collect b's properties

Here are a couple more tests that fail with array and mixed array/object (because of a stack overflow):


test('array with references to self wont loop', function(){
    var circularA = [],
        circularB = [];
    circularA.push(circularA);
    circularB.push(circularB);
    equals(QUnit.equiv(circularA, circularB), true, "Should not repeat test on array (ambigous test)");
   
    circularA.push( 'abc' );
    circularB.push( 'abc' );
    equals(QUnit.equiv(circularA, circularB), true, "Should not repeat test on array (ambigous test)");
   
    circularA.push( 'hello' );
    circularB.push( 'goodbye' );
    equals(QUnit.equiv(circularA, circularB), false, "Should not repeat test on array (unambigous test)");
});

test('mixed object/array with references to self wont loop', function(){
    var circularA = [{abc:null}],
        circularB = [{abc:null}];
    circularA[0].abc = circularA;
    circularB[0].abc = circularB;
   
    circularA.push(circularA);
    circularB.push(circularB);
    equals(QUnit.equiv(circularA, circularB), true, "Should not repeat test on object/array (ambigous test)");
   
    circularA[0].def = 1;
    circularB[0].def = 1;
    equals(QUnit.equiv(circularA, circularB), true, "Should not repeat test on object/array (ambigous test)");
   
    circularA[0].def = 1;
    circularB[0].def = 0;
    equals(QUnit.equiv(circularA, circularB), false, "Should not repeat test on object/array (unambigous test)");
});

And here is a patch:

    // Determine what is o.
@@ -788,7 +789,7 @@ QUnit.equiv = function () {
             },
 
             "array": function (b, a) {
-                var i;
+                var i, j, loop;
                 var len;
 
                 // b could be an object literal here
@@ -800,16 +801,26 @@ QUnit.equiv = function () {
                 if (len !== b.length) { // safe and faster
                     return false;
                 }
+               
+                parents.push(a);
                 for (i = 0; i < len; i++) {
-                    if ( ! innerEquiv(a[i], b[i])) {
+                    loop = false;
+                    for(j=0;j<parents.length;j++){
+                        if(parents[j] === a[i]){
+                            loop = true;//dont rewalk array
+                        }
+                    }
+                    if (!loop && ! innerEquiv(a[i], b[i])) {
+                        parents.pop();
                         return false;
                     }
                 }
+                parents.pop();
                 return true;
             },

sorry to push on this, it's a blocker for being able to say we can run the jquery 1.4.1 tests to completion out of the box with envjs 1.2.

Is there a better solution or am I missing an important issue? 

Thanks for any feed back.

Thatcher

oops thought I responded earlier.  I did clone qunit and applied the patch and added the tests.  I sent a pull request but here is the commit link if thats easier.

http://github.com/thatcher/qunit/tree/8c297bebad819b84f85cc19c53cb701a1b418f1a

Thanks,
Thatcher

I finally got the offset tests running again which was the last hurdle to completing the test cycle with 1.4.x in Envjs 1.2.