sproutcore 1.4.5-java → 1.5.0-java

data/lib/frameworks/sproutcore/frameworks/statechart/tests/statechart/create/assigned_root_state.js

@@ -0,0 +1,76 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC statechart */
+
+var obj1, rootState1, stateA, stateB;
+var obj2;
+
+module("SC.Statechart: Create Statechart with Assigned Root State Tests", {
+  setup: function() {
+    obj1 = SC.Object.extend(SC.StatechartManager, {
+      rootState: SC.State.design({
+        
+        initialSubstate: 'a',
+        
+        a: SC.State.design({
+          foo: function() {
+            this.gotoState('b');
+          }
+        }),
+        
+        b: SC.State.design({
+          bar: function() {
+            this.gotoState('a');
+          }
+        })
+        
+      })
+    });
+    
+    obj1 = obj1.create();
+    rootState1 = obj1.get('rootState');
+    stateA = obj1.getState('a');
+    stateB = obj1.getState('b');
+    
+    obj2 = SC.Object.extend(SC.StatechartManager, {
+      autoInitStatechart: NO,
+      rootState: SC.State.design()
+    });
+    
+    obj2 = obj2.create();
+  },
+  
+  teardown: function() {
+    obj1 = rootState1 = stateA = stateB = null;
+    obj2 = null;
+  }
+});
+
+test("check obj1", function() {
+  ok(obj1.get('isStatechart'), "obj should be statechart");
+  ok(obj1.get('statechartIsInitialized'), "obj should be an initialized statechart");
+  ok(SC.kindOf(rootState1, SC.State), "root state should be kind of SC.State");
+  equals(obj1.get('initialState'), null, "obj initialState should be null");
+  
+  ok(stateA.get('isCurrentState'), "state A should be current state");
+  ok(!stateB.get('isCurrentState'), "state B should not be current state");
+  
+  equals(rootState1.get('owner'), obj1, "root state's owner should be obj");
+  equals(stateA.get('owner'), obj1, "state A's owner should be obj");
+  equals(stateB.get('owner'), obj1, "state B's owner should be obj");
+  
+  obj1.sendEvent('foo');
+  
+  ok(!stateA.get('isCurrentState'), "state A should not be current state");
+  ok(stateB.get('isCurrentState'), "state B should be current state");
+});
+
+test("check obj2", function() {
+  ok(obj2.get('isStatechart'), "obj should be statechart");
+  ok(!obj2.get('statechartIsInitialized'), "obj not should be an initialized statechart");
+  
+  obj2.initStatechart();
+  
+  ok(obj2.get('statechartIsInitialized'), "obj should be an initialized statechart");
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/statechart/create/unassigned_root_state.js

@@ -0,0 +1,162 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC statechart State */
+
+var obj1, rootState1, stateA, stateB;
+var obj2, rootState2, stateC, stateD;
+var obj3, rootState3, stateE, rootStateExample;
+var obj4;
+var owner;
+
+module("SC.Statechart: Create Statechart with Unassigned Root State Tests", {
+  setup: function() {
+    owner = SC.Object.create();
+    
+    obj1 = SC.Object.extend(SC.StatechartManager, {
+      
+      initialState: 'stateA',
+      
+      stateA: SC.State.design({
+        foo: function() {
+          this.gotoState('stateB');
+        }
+      }),
+      
+      stateB: SC.State.design({
+        bar: function() {
+          this.gotoState('stateA');
+        }
+      })
+      
+    });
+    
+    obj1 = obj1.create();
+    rootState1 = obj1.get('rootState');
+    stateA = obj1.getState('stateA');
+    stateB = obj1.getState('stateB');  
+    
+    obj2 = SC.Object.extend(SC.StatechartManager, {
+      
+      statesAreConcurrent: YES,
+      
+      stateC: SC.State.design({
+        foo: function() {
+          this.gotoState('stateD');
+        }
+      }),
+      
+      stateD: SC.State.design({
+        bar: function() {
+          this.gotoState('stateC');
+        }
+      })
+      
+    });
+    
+    obj2 = obj2.create();
+    rootState2 = obj2.get('rootState');
+    stateC = obj2.getState('stateC');
+    stateD = obj2.getState('stateD');  
+    
+    rootStateExample = SC.State.extend({ test: 'foo' });
+    
+    obj3 = SC.Object.extend(SC.StatechartManager, {
+      owner: owner,
+      initialState: 'stateE',
+      rootStateExample: rootStateExample,
+      stateE: SC.State.design()
+    });
+    
+    obj3 = obj3.create();
+    rootState3 = obj3.get('rootState');
+    stateE = obj3.getState('stateE');
+    
+    obj4 = SC.Object.extend(SC.StatechartManager, {
+      autoInitStatechart: NO,
+      initialState: 'stateF',
+      rootStateExample: rootStateExample,
+      stateF: SC.State.design()
+    });
+    
+    obj4 = obj4.create();
+  },
+  
+  teardown: function() {
+    obj1 = rootState1 = stateA = stateB = null;
+    obj2 = rootState2 = stateC = stateD = null;
+    obj3 = rootState3 = stateE = rootStateExample = null;
+    obj4 = null;
+  }
+});
+
+test("check obj1 statechart", function() {
+  ok(obj1.get('isStatechart'), "obj should be a statechart");
+  ok(obj1.get('statechartIsInitialized'), "obj should be an initialized statechart");
+  ok(SC.kindOf(rootState1, SC.State), "root state should be kind of SC.State");
+  ok(!rootState1.get('substateAreConcurrent'), "root state's substates should not be concurrent");
+  
+  equals(obj1.get('initialState'), stateA, "obj's initialState should be state A");
+  equals(rootState1.get('initialSubstate'), stateA, "root state's initialState should be state A");
+  equals(stateA, rootState1.getSubstate('stateA'), "obj.stateA and rootState.stateA should be equal");
+  equals(stateB, rootState1.getSubstate('stateB'), "obj.stateB and rootState.stateB should be equal");
+  
+  equals(rootState1.get('owner'), obj1, "root state's owner should be obj");
+  equals(stateA.get('owner'), obj1, "state A's owner should be obj");
+  equals(stateB.get('owner'), obj1, "state B's owner should be obj");
+  
+  ok(stateA.get('isCurrentState'), "state A should be current state");
+  ok(!stateB.get('isCurrentState'), "state B should not be current state");
+  
+  obj1.sendEvent('foo');
+  
+  ok(!stateA.get('isCurrentState'), "state A should not be current state");
+  ok(stateB.get('isCurrentState'), "state B should be current state");
+});
+
+test("check obj2 statechart", function() {
+  ok(obj2.get('isStatechart'), "obj should be a statechart");
+  ok(obj2.get('statechartIsInitialized'), "obj should be an initialized statechart");
+  ok(SC.kindOf(rootState2, SC.State), "root state should be kind of SC.State");
+  ok(rootState2.get('substatesAreConcurrent'), "root state's substates should be concurrent");
+  
+  equals(obj2.get('initialState'), null, "obj's initialState should be null");
+  equals(rootState2.get('initialSubstate'), null, "root state's initialState should be null");
+  equals(stateC, rootState2.getSubstate('stateC'), "obj.stateC and rootState.stateC should be equal");
+  equals(stateD, rootState2.getSubstate('stateD'), "obj.stateD and rootState.stateD should be equal");
+  
+  equals(rootState2.get('owner'), obj2, "root state's owner should be obj");
+  equals(stateC.get('owner'), obj2, "state C's owner should be obj");
+  equals(stateD.get('owner'), obj2, "state D's owner should be obj");
+  
+  ok(stateC.get('isCurrentState'), "state C should be current state");
+  ok(stateD.get('isCurrentState'), "state D should not be current state");
+});
+
+test("check obj3 statechart", function() {
+  ok(obj3.get('isStatechart'), "obj should be a statechart");
+  ok(obj3.get('statechartIsInitialized'), "obj should be an initialized statechart");
+  ok(SC.kindOf(rootState3, rootStateExample), "root state should be kind of rootStateExample");
+  ok(!rootState3.get('substatesAreConcurrent'), "root state's substates should be concurrent");
+  
+  equals(rootState3.get('owner'), owner, "root state's owner should be owner");
+  equals(stateE.get('owner'), owner, "state C's owner should be owner");
+  
+  equals(obj3.get('initialState'), stateE, "obj's initialState should be stateE");
+  equals(rootState3.get('initialSubstate'), stateE, "root state's initialState should be stateE");
+  equals(stateE, rootState3.getSubstate('stateE'), "obj.stateE and rootState.stateE should be equal");
+  
+  ok(stateE.get('isCurrentState'), "state E should be current state");
+});
+
+test("check obj4 statechart", function() {
+  ok(obj4.get('isStatechart'), "obj should be a statechart");
+  ok(!obj4.get('statechartIsInitialized'), "obj should not be an initialized statechart");
+  equals(obj4.get('rootState'), null, "obj's root state should be null");
+  
+  obj4.initStatechart();
+  
+  ok(obj4.get('statechartIsInitialized'), "obj should be an initialized statechart");
+  ok(obj4.get('rootState'), "obj's root state should not be null");
+  equals(obj4.get('rootState').getSubstate('stateF'), obj4.getState('stateF'), "obj.stateF should be equal to rootState.stateF");
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/statechart/destroy.js

@@ -0,0 +1,73 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC statechart State */
+
+var obj, rootState, stateA, stateB;
+
+module("SC.Statechart: Destroy Statechart Tests", {
+  setup: function() {
+    
+    obj = SC.Object.create(SC.StatechartManager, {
+      
+      initialState: 'stateA',
+      
+      stateA: SC.State.design(),
+      
+      stateB: SC.State.design()
+      
+    });
+    
+    obj.initStatechart();
+    rootState = obj.get('rootState');
+    stateA = obj.getState('stateA');
+    stateB = obj.getState('stateB');
+  },
+  
+  teardown: function() {
+    obj = rootState = stateA = stateB = null;
+  }
+});
+
+test("check obj before and after destroy", function() {
+  ok(!obj.get('isDestroyed'), "obj should not be destroyed");
+  ok(obj.hasObserverFor('owner'), "obj should have observers for property owner");
+  ok(obj.hasObserverFor('trace'), "obj should have observers for property trace");
+  equals(obj.get('rootState'), rootState, "object should have a root state");
+  
+  ok(!rootState.get('isDestroyed'), "root state should not be destoryed");
+  equals(rootState.getPath('substates.length'), 2, "root state should have two substates");
+  equals(rootState.getPath('currentSubstates.length'), 1, "root state should one current substate");
+  equals(rootState.get('historyState'), stateA, "root state should have history state of A");
+  equals(rootState.get('initialSubstate'), stateA, "root state should have initial substate of A");
+  equals(rootState.get('statechart'), obj, "root state's statechart should be obj");
+  equals(rootState.get('owner'), obj, "root state's owner should be obj");
+  
+  ok(!stateA.get('isDestroyed'), "state A should not be destoryed");
+  equals(stateA.get('parentState'), rootState, "state A should have a parent state of root state");
+  
+  ok(!stateB.get('isDestroyed'), "state B should not be destroyed");
+  equals(stateB.get('parentState'), rootState, "state B should have a parent state of root state");
+  
+  obj.destroy();
+
+  ok(obj.get('isDestroyed'), "obj should be destroyed");
+  ok(!obj.hasObserverFor('owner'), "obj should not have observers for property owner");
+  ok(!obj.hasObserverFor('trace'), "obj should not have observers for property trace");
+  equals(obj.get('rootState'), null, "obj should not have a root state");
+  
+  ok(rootState.get('isDestroyed'), "root state should be destroyed");
+  equals(rootState.get('substates'), null, "root state should not have substates");
+  equals(rootState.get('currentSubstates'), null, "root state should not have current substates");
+  equals(rootState.get('parentState'), null, "root state should not have a parent state");
+  equals(rootState.get('historyState'), null, "root state should not have a history state");
+  equals(rootState.get('initialSubstate'), null, "root state should not have an initial substate");
+  equals(rootState.get('statechart'), null, "root state's statechart should be null");
+  equals(rootState.get('owner'), null, "root state's owner should be null");
+  
+  ok(stateA.get('isDestroyed'), "state A should be destroyed");
+  equals(stateA.get('parentState'), null, "state A should not have a parent state");
+  
+  ok(stateB.get('isDestroyed'), "state B should be destroyed");
+  equals(stateB.get('parentState'), null, "state B should not have a parent state");
+});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/statechart/invoke_state_method.js

@@ -0,0 +1,241 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC statechart State */
+
+var TestState;
+var obj1, rootState1, stateA, stateB;
+var obj2, rootState2, stateC, stateD;
+
+module("SC.Statechart: invokeStateMethod Tests", {
+  setup: function() {
+    TestState = SC.State.extend({
+      testInvokedCount: 0,
+      arg1: undefined,
+      arg2: undefined,
+      returnValue: undefined,
+      
+      testInvoked: function() {
+        return this.get('testInvokedCount') > 0;
+      }.property('testInvokedCount'),
+      
+      test: function(arg1, arg2) {
+        this.set('testInvokedCount', this.get('testInvokedCount') + 1);
+        this.set('arg1', arg1);
+        this.set('arg2', arg2);
+        if (this.get('returnValue') !== undefined) {
+          return this.get('returnValue');
+        } 
+      }
+    });
+    
+    obj1 = SC.Object.extend(SC.StatechartManager, {
+      
+      initialState: 'stateA',
+      
+      rootStateExample: TestState.design({
+        testX: function(arg1, arg2) {
+          this.set('testInvokedCount', this.get('testInvokedCount') + 1);
+          this.set('arg1', arg1);
+          this.set('arg2', arg2);
+          if (this.get('returnValue') !== undefined) {
+            return this.get('returnValue');
+          } 
+        }
+      }),
+      
+      stateA: TestState.design(),
+      
+      stateB: TestState.design()
+      
+    });
+    
+    obj1 = obj1.create();
+    rootState1 = obj1.get('rootState');
+    stateA = obj1.getState('stateA');
+    stateB = obj1.getState('stateB');
+    
+    obj2 = SC.Object.extend(SC.StatechartManager, {
+      
+      statesAreConcurrent: YES,
+      
+      rootStateExample: TestState.design({
+        testX: function(arg1, arg2) {
+          this.set('testInvokedCount', this.get('testInvokedCount') + 1);
+          this.set('arg1', arg1);
+          this.set('arg2', arg2);
+          if (this.get('returnValue') !== undefined) {
+            return this.get('returnValue');
+          } 
+        }
+      }),
+      
+      stateC: TestState.design(),
+      
+      stateD: TestState.design()
+      
+    });
+    
+    obj2 = obj2.create();
+    rootState2 = obj2.get('rootState');
+    stateC = obj2.getState('stateC');
+    stateD = obj2.getState('stateD');
+  },
+  
+  teardown: function() {
+    TestState = obj1 = rootState1 = stateA = stateB = null;
+    obj2 = rootState2 = stateC = stateD = null;
+  }
+});
+
+test("check obj1 - invoke method test1", function() {
+  var result = obj1.invokeStateMethod('test1');
+  ok(!rootState1.get('testInvoked'), "root state test method should not have been invoked");
+  ok(!stateA.get('testInvoked'), "state A's test method should not have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state A, no args, no return value", function() {
+  var result = obj1.invokeStateMethod('test');
+  equals(stateA.get('testInvokedCount'), 1, "state A's test method should have been invoked once");
+  equals(stateA.get('arg1'), undefined, "state A's arg1 method should be undefined");
+  equals(stateA.get('arg2'), undefined, "state A's arg2 method should be undefined");
+  equals(result, undefined, "returned result should be undefined");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state A, one args, no return value", function() {
+  var result = obj1.invokeStateMethod('test', "frozen");
+  ok(stateA.get('testInvoked'), "state A's test method should have been invoked");
+  equals(stateA.get('arg1'), "frozen", "state A's arg1 method should be 'frozen'");
+  equals(stateA.get('arg2'), undefined, "state A's arg2 method should be undefined");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state A, two args, no return value", function() {
+  var result = obj1.invokeStateMethod('test', 'frozen', 'canuck');
+  ok(stateA.get('testInvoked'), "state A's test method should have been invoked");
+  equals(stateA.get('arg1'), "frozen", "state A's arg1 method should be 'frozen'");
+  equals(stateA.get('arg2'), "canuck", "state A's arg2 method should be undefined");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state A, no args, return value", function() {
+  stateA.set('returnValue', 100);
+  var result = obj1.invokeStateMethod('test');
+  ok(stateA.get('testInvoked'), "state A's test method should have been invoked");
+  equals(result, 100, "returned result should be 100");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state B, two args, return value", function() {
+  stateB.set('returnValue', 100);
+  obj1.gotoState(stateB);
+  ok(stateB.get('isCurrentState'), "state B should be curren state");
+  var result = obj1.invokeStateMethod('test', 'frozen', 'canuck');
+  ok(!stateA.get('testInvoked'), "state A's test method should not have been invoked");
+  equals(stateB.get('testInvokedCount'), 1, "state B's test method should have been invoked once");
+  equals(stateB.get('arg1'), 'frozen', "state B's arg1 method should be 'frozen'");
+  equals(stateB.get('arg2'), 'canuck', "state B's arg2 method should be 'canuck'");
+  equals(result, 100, "returned result should be 100");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method test, current state A, use callback", function() {
+  var callbackState, callbackResult;
+  obj1.invokeStateMethod('test', function(state, result) {
+    callbackState = state;
+    callbackResult = result;
+  });
+  ok(stateA.get('testInvoked'), "state A's test method should have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+  equals(callbackState, stateA, "state should be state A");
+  equals(callbackResult, undefined, "result should be undefined");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+});
+
+test("check obj1- invoke method test, current state B, use callback", function() {
+  var callbackState, callbackResult;
+  obj1.gotoState(stateB);
+  stateB.set('returnValue', 100);
+  obj1.invokeStateMethod('test', function(state, result) {
+    callbackState = state;
+    callbackResult = result;
+  });
+  ok(!stateA.get('testInvoked'), "state A's test method should not have been invoked");
+  ok(stateB.get('testInvoked'), "state B's test method should have been invoked");
+  equals(callbackState, stateB, "state should be state B");
+  equals(callbackResult, 100, "result should be 100");
+  ok(!rootState1.get('testInvoked'), "root state's test method should not have been invoked");
+});
+
+test("check obj1 - invoke method testX", function() {
+  rootState1.set('returnValue', 100);
+  var result = obj1.invokeStateMethod('testX');
+  equals(rootState1.get('testInvokedCount'), 1, "root state's testX method should not have been invoked once");
+  equals(result, 100, "result should have value 100");
+  ok(!stateA.get('testInvoked'), "state A's test method should have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj2 - invoke method test1", function() {
+  var result = obj2.invokeStateMethod('test1');
+  ok(!rootState2.get('testInvoked'), "root state test method should not have been invoked");
+  ok(!stateC.get('testInvoked'), "state A's test method should not have been invoked");
+  ok(!stateD.get('testInvoked'), "state B's test method should not have been invoked");
+});
+
+test("check obj2 - invoke test, no args, no return value", function() {
+  var result = obj2.invokeStateMethod('test');
+  equals(stateC.get('testInvokedCount'), 1, "state C's test method should have been invoked once");
+  equals(stateD.get('testInvokedCount'), 1, "state D's test method should have been invoked once");
+  ok(!rootState1.get('testInvoked'), "root state test method should not have been invoked");
+  equals(stateC.get('arg1'), undefined, "state C's arg1 method should be undefined");
+  equals(stateC.get('arg2'), undefined, "state C's arg2 method should be undefined");
+  equals(stateD.get('arg1'), undefined, "state D's arg1 method should be undefined");
+  equals(stateD.get('arg2'), undefined, "state D's arg2 method should be undefined");
+  equals(result, undefined, "returned result should be undefined");
+});
+
+test("check obj2 - invoke test, two args, return value, callback", function() {
+  var numCallbacks = 0,
+      callbackInfo = {};
+  stateC.set('returnValue', 100);
+  stateD.set('returnValue', 200);
+  var result = obj2.invokeStateMethod('test', 'frozen', 'canuck', function(state, result) {
+    numCallbacks += 1;
+    callbackInfo['state' + numCallbacks] = state;
+    callbackInfo['result' + numCallbacks] = result;
+  });
+  
+  ok(!rootState1.get('testInvoked'), "root state test method should not have been invoked");
+  equals(stateC.get('testInvokedCount'), 1, "state C's test method should have been invoked once");
+  equals(stateD.get('testInvokedCount'), 1, "state D's test method should have been invoked once");
+  
+  equals(stateC.get('arg1'), 'frozen', "state C's arg1 method should be 'frozen'");
+  equals(stateC.get('arg2'), 'canuck', "state C's arg2 method should be 'canuck'");
+  
+  equals(stateD.get('arg1'), 'frozen', "state D's arg1 method should be 'frozen'");
+  equals(stateD.get('arg2'), 'canuck', "state D's arg2 method should be 'canuck'");
+  
+  equals(numCallbacks, 2, "callback should have been invoked twice");
+  equals(callbackInfo['state1'], stateC, "first callback state arg should be state C");
+  equals(callbackInfo['result1'], 100, "first callback result arg should be 100");
+  equals(callbackInfo['state2'], stateD, "second callback state arg should be state D");
+  equals(callbackInfo['result2'], 200, "second callback result arg should be 200");
+  
+  equals(result, undefined, "returned result should be undefined");
+});
+
+test("check obj2 - invoke method testX", function() {
+  rootState2.set('returnValue', 100);
+  var result = obj2.invokeStateMethod('testX');
+  equals(rootState2.get('testInvokedCount'), 1, "root state's testX method should not have been invoked once");
+  equals(result, 100, "result should have value 100");
+  ok(!stateA.get('testInvoked'), "state A's test method should have been invoked");
+  ok(!stateB.get('testInvoked'), "state B's test method should not have been invoked");
+});