sproutcore 1.6.0.beta.3-java → 1.6.0-java

data/lib/frameworks/sproutcore/frameworks/statechart/system/state.js

@@ -8,6 +8,7 @@
 /*globals SC */
 
 /**
+  @class
 
   Represents a state within a statechart. 
   
@@ -17,11 +18,14 @@
   You do not create an instance of a state itself. The statechart manager will go through its 
   state heirarchy and create the states itself.
 
-  @author Michael Cohen
+  For more information on using statecharts, see SC.StatechartManager.
 
+  @author Michael Cohen
+  @extends SC.Object
 */
-SC.State = SC.Object.extend({
-  
+SC.State = SC.Object.extend(
+  /** @lends SC.State.prototype */ {
+
   /**
     The name of the state
     
@@ -1025,7 +1029,7 @@ SC.State = SC.Object.extend({
     var sc = this.get('statechart');
     sc.statechartLogError(msg);
   }
-  
+
 });
 
 /**
@@ -1057,6 +1061,14 @@ SC.State.plugin = function(value) {
   var args = SC.A(arguments); args.shift();
   var func = function() {
     var klass = SC.objectForPropertyPath(value);
+    if (!klass) {
+      console.error('SC.State.plugin: Unable to determine path %@'.fmt(value));
+      return undefined;
+    }
+    if (!klass.isClass || !klass.kindOf(SC.State)) {
+      console.error('SC.State.plugin: Unable to extend. %@ must be a class extending from SC.State'.fmt(value));
+      return undefined;
+    }
     return klass.extend.apply(klass, args);
   };
   func.statePlugin = YES;
@@ -1064,190 +1076,3 @@ SC.State.plugin = function(value) {
 };
 
 SC.State.design = SC.State.extend;
-
-/**
-  Extends the JS Function object with the handleEvents method that
-  will provide more advanced event handling capabilities when constructing
-  your statechart's states.
-  
-  By default, when you add a method to a state, the state will react to 
-  events that matches a method's name, like so:
-  
-      state = SC.State.extend({
-        // Will be invoked when a event named "foo" is sent to this state
-        foo: function(event, sender, context) { ... }
-      });
-  
-  In some situations, it may be advantageous to use one method that can react to 
-  multiple events instead of having multiple methods that essentially all do the
-  same thing. In order to set a method to handle more than one event you use
-  the handleEvents method which can be supplied a list of string and/or regular
-  expressions. The following example demonstrates the use of handleEvents:
-
-      state = SC.State.extend({
-        eventHandlerA: function(event, sender, context) {
-        }.handleEvents('foo', 'bar'),
-
-        eventHandlerB: function(event, sender, context) {
-        }.handleEvents(/num\d/, 'decimal')
-      });
-
-  Whenever events 'foo' and 'bar' are sent to the state, the method eventHandlerA
-  will be invoked. When there is an event that matches the regular expression
-  /num\d/ or the event is 'decimal' then eventHandlerB is invoked. In both 
-  cases, the name of the event will be supplied to the event handler. 
-  
-  It should be noted that the use of regular expressions may impact performance
-  since that statechart will not be able to fully optimize the event handling logic based
-  on its use. Therefore the use of regular expression should be used sparingly. 
-  
-  @param {(String|RegExp)...} args
-*/
-Function.prototype.handleEvents = function() {
-  this.isEventHandler = YES;
-  this.events = arguments;
-  return this;
-};
-
-/**
-  Extends the JS Function object with the stateObserves method that will
-  create a state observe handler on a given state object. 
-  
-  Use a stateObserves() instead of the common observes() method when you want a 
-  state to observer changes to some property on the state itself or some other 
-  object. 
-  
-  Any method on the state that has stateObserves is considered a state observe
-  handler and behaves just like when you use observes() on a method, but with an
-  important difference. When you apply stateObserves to a method on a state, those
-  methods will be active *only* when the state is entered, otherwise those methods
-  will be inactive. This removes the need for you having to explicitly call
-  addObserver and removeObserver. As an example:
-  
-      state = SC.State.extend({
-        foo: null,
-        user: null,
-        observeHandlerA: function(target, key) {        
-        }.stateObserves('MyApp.someController.status'),
-
-        observeHandlerB: function(target, key) {
-        }.stateObserves('foo'),
-
-        observeHandlerC: function(target, key) {
-        }.stateObserves('.user.name', '.user.salary')
-      });
-  
-  Above, state has three state observe handlers: observeHandlerA, observeHandlerB, and
-  observeHandlerC. When state is entered, the state will automatically add itself as
-  an observer for all of its registered state observe handlers. Therefore when
-  foo changes, observeHandlerB will be invoked, and when MyApp.someController's status
-  changes then observeHandlerA will be invoked. The moment that state is exited then
-  the state will automatically remove itself as an observer for all of its registered
-  state observe handlers. Therefore none of the state observe handlers will be
-  invoked until the next time the state is entered. 
-  
-  @param {String...} args
-*/
-Function.prototype.stateObserves = function() {
-  this.isStateObserveHandler = YES;
-  this.args = SC.A(arguments);
-  return this;
-};
-
-/**
-  Represents a history state that can be assigned to a SC.State object's
-  initialSubstate property. 
-  
-  If a SC.HistoryState object is assigned to a state's initial substate, 
-  then after a state is entered the statechart will refer to the history 
-  state object to determine the next course of action. If the state has 
-  its historyState property assigned then the that state will be entered, 
-  otherwise the default state assigned to history state object will be entered.
-  
-  An example of how to use:
-  
-    stateA: SC.State.design({
-      initialSubstate: SC.HistoryState({
-        defaultState: 'stateB'
-      }),
-      
-      stateB: SC.State.design({ ... }),
-      
-      stateC: SC.State.design({ ... })
-    })
-*/
-SC.HistoryState = SC.Object.extend({
-
-  /**
-    Used to indicate if the statechart should recurse the 
-    history states after entering the this object's parent state
-    
-    @property {Boolean}
-  */
-  isRecursive: NO,
-  
-  /**
-    The default state to enter if the parent state does not
-    yet have its historyState property assigned to something 
-    other than null.
-    
-    The value assigned to this property must be the name of an
-    immediate substate that belongs to the parent state. The
-    statechart will manage the property upon initialization.
-    
-    @property {String}
-  */
-  defaultState: null,
-  
-  /** @private
-    Managed by the statechart 
-    
-    The statechart that owns this object.
-  */
-  statechart: null,
-  
-  /** @private
-    Managed by the statechart 
-  
-    The state that owns this object
-  */
-  parentState: null,
-  
-  /**
-    Used by the statechart during a state transition process. 
-    
-    Returns a state to enter based on whether the parent state has
-    its historyState property assigned. If not then this object's
-    assigned default state is returned.
-  */
-  state: function() {
-    var defaultState = this.get('defaultState'),
-        historyState = this.getPath('parentState.historyState');
-    return !!historyState ? historyState : defaultState;
-  }.property().cacheable(),
-  
-  /** @private */
-  parentHistoryStateDidChange: function() {
-    this.notifyPropertyChange('state');
-  }.observes('*parentState.historyState')
-  
-});
-
-/** 
-  The default name given to an empty state
-*/
-SC.EMPTY_STATE_NAME = "__EMPTY_STATE__";
-
-/**
-  Represents an empty state that gets assigned as a state's initial substate 
-  if the state does not have an initial substate defined.
-*/
-SC.EmptyState = SC.State.extend({
-  
-  name: SC.EMPTY_STATE_NAME,
-  
-  enterState: function() {
-    this.stateLogWarning("No initial substate was defined for state %@. Entering default empty state".fmt(this.get('parentState')));
-  }
-  
-});

data/lib/frameworks/sproutcore/frameworks/statechart/system/statechart.js

@@ -10,6 +10,8 @@
 sc_require('system/state');
 
 /**
+  @class
+
   The startchart manager mixin allows an object to be a statechart. By becoming a statechart, the
   object can then be manage a set of its own states.
   
@@ -60,7 +62,7 @@ sc_require('system/state');
   
   If you liked to specify a class that should be used as the root state but using the above method to defined
   states, you can set the rootStateExample property with a class that extends from SC.State. If the 
-  rootStateExaple property is not explicitly assigned the then default class used will be SC.State.
+  rootStateExample property is not explicitly assigned the then default class used will be SC.State.
   
   To provide your statechart with orthogonality, you use concurrent states. If you use concurrent states,
   then your statechart will have multiple current states. That is because each concurrent state represents an
@@ -163,10 +165,9 @@ sc_require('system/state');
   into as many files as you see fit.
 
   @author Michael Cohen
-
 */
 
-SC.StatechartManager = {
+SC.StatechartManager = /** @scope SC.StatechartManager.prototype */{
   
   // Walk like a duck
   isResponderContext: YES,
@@ -547,7 +548,8 @@ SC.StatechartManager = {
         trace = this.get('allowStatechartTracing'),
         rootState = this.get('rootState'),
         paramState = state,
-        paramFromCurrentState = fromCurrentState;
+        paramFromCurrentState = fromCurrentState,
+        msg;
     
     state = rootState.getSubstate(state);
     
@@ -578,7 +580,7 @@ SC.StatechartManager = {
       // Check to make sure the current state given is actually a current state of this statechart
       fromCurrentState = rootState.getSubstate(fromCurrentState);
       if (SC.none(fromCurrentState) || !fromCurrentState.get('isCurrentState')) {
-        var msg = "Can not to goto state %@. %@ is not a recognized current state in statechart";
+        msg = "Can not to goto state %@. %@ is not a recognized current state in statechart";
         this.statechartLogError(msg.fmt(paramState, paramFromCurrentState));
         this._gotoStateLocked = NO;
         return;
@@ -588,12 +590,18 @@ SC.StatechartManager = {
       // No explicit current state to start from; therefore, just use the first current state as 
       // a default, if there is a current state.
       fromCurrentState = this.get('currentStates')[0];
+      msg = "gotoState: fromCurrentState not explicitly provided. Using a default current state to transition from: %@";
+      this.statechartLogWarning(msg.fmt(fromCurrentState));
     }
         
     if (trace) {
       this.statechartLogTrace("BEGIN gotoState: %@".fmt(state));
-      this.statechartLogTrace("starting from current state: %@".fmt(fromCurrentState));
-      this.statechartLogTrace("current states before: %@".fmt(this.get('currentStates')));
+      msg = "starting from current state: %@";
+      msg = msg.fmt(fromCurrentState ? fromCurrentState : '---');
+      this.statechartLogTrace(msg);
+      msg = "current states before: %@";
+      msg = msg.fmt(this.getPath('currentStates.length') > 0 ? this.get('currentStates') : '---');
+      this.statechartLogTrace(msg);
     }
 
     // If there is a current state to start the transition process from, then determine what
@@ -739,7 +747,7 @@ SC.StatechartManager = {
       parentState = parentState.get('parentState');
     }
       
-    if (this.get('allowStatechartTracing')) this.statechartLogTrace("exiting state: %@".fmt(state));
+    if (this.get('allowStatechartTracing')) this.statechartLogTrace("<-- exiting state: %@".fmt(state));
     
     state.set('currentSubstates', []);
     state.notifyPropertyChange('isCurrentState');
@@ -787,7 +795,7 @@ SC.StatechartManager = {
       parentState = parentState.get('parentState');
     }
     
-    if (this.get('allowStatechartTracing')) this.statechartLogTrace("entering state: %@".fmt(state));
+    if (this.get('allowStatechartTracing')) this.statechartLogTrace("--> entering state: %@".fmt(state));
     
     state.notifyPropertyChange('isCurrentState');
   
@@ -1474,73 +1482,3 @@ SC.Statechart = SC.Object.extend(SC.StatechartManager, {
 });
 
 SC.Statechart.design = SC.Statechart.extend;
-
-/**
-  Represents a call that is intended to be asynchronous. This is
-  used during a state transition process when either entering or
-  exiting a state.
-*/
-SC.Async = SC.Object.extend({
-  
-  func: null,
-  
-  arg1: null,
-  
-  arg2: null,
-  
-  /** @private
-    Called by the statechart
-  */
-  tryToPerform: function(state) {
-    var func = this.get('func'),
-        arg1 = this.get('arg1'),
-        arg2 = this.get('arg2'),
-        funcType = SC.typeOf(func);
-      
-    if (funcType === SC.T_STRING) {
-      state.tryToPerform(func, arg1, arg2);
-    } 
-    else if (funcType === SC.T_FUNCTION) {
-      func.apply(state, [arg1, arg2]);
-    }
-  }
-  
-});
-
-/**
-  Singleton
-*/
-SC.Async.mixin({
-  
-  /**
-    Call in either a state's enterState or exitState method when you
-    want a state to perform an asynchronous action, such as an animation.
-    
-    Examples:
-    
-        SC.State.extend({
-    
-          enterState: function() {
-            return SC.Async.perform('foo');
-          },
-      
-          exitState: function() {
-            return SC.Async.perform('bar', 100);
-          }
-      
-          foo: function() { ... },
-      
-          bar: function(arg) { ... }
-    
-        });
-    
-    @param func {String|Function} the functio to be invoked on a state
-    @param arg1 Optional. An argument to pass to the given function
-    @param arg2 Optional. An argument to pass to the given function
-    @return {SC.Async} a new instance of a SC.Async
-  */
-  perform: function(func, arg1, arg2) {
-    return SC.Async.create({ func: func, arg1: arg1, arg2: arg2 });
-  }
-  
-});

data/lib/frameworks/sproutcore/frameworks/statechart/tests/debug/sequence_matcher.js

@@ -0,0 +1,464 @@
+// ==========================================================================
+// SC.Statechart Unit Test
+// ==========================================================================
+/*globals SC */
+
+var obj, monitor, rootState, a, b, c, d, e, m, n, o, p, x, y;
+
+module("SC.Statechart: Destroy Statechart Tests", {
+  setup: function() {
+    
+    obj = SC.Object.create(SC.StatechartManager, {
+      
+      initialState: 'A',
+      A: SC.State.design(),
+      B: SC.State.design(),
+      C: SC.State.design(),
+      D: SC.State.design(),
+      E: SC.State.design(),
+      M: SC.State.design(),
+      N: SC.State.design(),
+      O: SC.State.design(),
+      P: SC.State.design(),
+      X: SC.State.design(),
+      Y: SC.State.design()
+      
+    });
+    
+    obj.initStatechart();
+    rootState = obj.get('rootState');
+    a = obj.getState('A');
+    b = obj.getState('B');
+    c = obj.getState('C');
+    d = obj.getState('D');
+    e = obj.getState('E');
+    m = obj.getState('M');
+    n = obj.getState('N');
+    o = obj.getState('O');
+    p = obj.getState('P');
+    x = obj.getState('X');
+    y = obj.getState('Y');
+    
+    monitor = SC.StatechartMonitor.create({ statechart: obj });
+  },
+  
+  teardown: function() {
+    obj = monitor = rootState = null;
+    a = b = c = d = e = m = n = o = p = x = y = null;
+  }
+});
+
+test("match against sequence entered A", function() {
+  monitor.pushEnteredState(a);
+  
+  var matcher = monitor.matchSequence();
+  
+  ok(matcher.begin().entered(a).end(), "should match entered A");
+  ok(matcher.begin().entered('A').end(), "should match entered 'A'");
+  ok(!matcher.begin().entered(b).end(), "should not match entered B");
+  ok(!matcher.begin().exited(a).end(), "should not match exited A");
+  ok(!matcher.begin().exited(b).end(), "should not match exited B");
+  ok(!matcher.begin().entered(a, b).end(), "should not match entered [A, B]");
+  ok(!matcher.begin().entered(a).entered(b).end(), "should not match entered A, entered B");
+});
+
+test("match against sequence exited A", function() {
+  monitor.pushExitedState(a);
+  
+  var matcher = monitor.matchSequence();
+  
+  ok(matcher.begin().exited(a).end(), "should match exited A");
+  ok(matcher.begin().exited('A').end(), "should match exited 'A'");
+  ok(!matcher.begin().exited(b).end(), "should not match exited B");
+  ok(!matcher.begin().entered(a).end(), "should not match entered A");
+  ok(!matcher.begin().entered(b).end(), "should not match entered B");
+  ok(!matcher.begin().exited(a, b).end(), "should not match exited [A, B]");
+  ok(!matcher.begin().exited(a).exited(b).end(), "should not match exited A, exited B");
+});
+
+test("match against sequence entered A, entered B", function() {
+  monitor.pushEnteredState(a);
+  monitor.pushEnteredState(b);
+  
+  var matcher = monitor.matchSequence();
+  
+  ok(matcher.begin().entered(a, b).end(), "should match entered [A, B]");
+  ok(matcher.begin().entered('A', 'B').end(), "should match entered ['A', 'B']");
+  ok(matcher.begin().entered(a).entered(b).end(), "should match entered A, entered B");
+  ok(!matcher.begin().entered(a).end(), "should not match entered A");
+  ok(!matcher.begin().entered(b).end(), "should not match entered B");
+  ok(!matcher.begin().entered(b, a).end(), "should not match entered [B, A]");
+  ok(!matcher.begin().entered('B', 'A').end(), "should match entered ['B', 'A']");
+  ok(!matcher.begin().entered(b).entered(a).end(), "should not matched entered B, entered A");
+  ok(!matcher.begin().entered(a, c).end(), "should not match entered [A, C]");
+  ok(!matcher.begin().entered('A', 'C').end(), "should not match entered [A, C]");
+  ok(!matcher.begin().entered(a).entered(c).end(), "should not match entered A, entered C");
+  ok(!matcher.begin().entered(a, b, c).end(), "should not match entered [A, B, C]");
+});
+
+test("match against sequence exited A, exited B", function() {
+  monitor.pushExitedState(a);
+  monitor.pushExitedState(b);
+  
+  var matcher = monitor.matchSequence();
+  
+  ok(matcher.begin().exited(a, b).end(), "should match exited [A, B]");
+  ok(matcher.begin().exited('A', 'B').end(), "should match exited ['A', 'B']");
+  ok(matcher.begin().exited(a).exited(b).end(), "should match exited A, entered B");
+  ok(!matcher.begin().exited(a).end(), "should not match exited A");
+  ok(!matcher.begin().exited(b).end(), "should not match exited B");
+  ok(!matcher.begin().exited(b, a).end(), "should not match exited [B, A]");
+  ok(!matcher.begin().exited('B', 'A').end(), "should not match exited ['B', 'A']");
+  ok(!matcher.begin().exited(b).exited(a).end(), "should not matched exited B, exited A");
+  ok(!matcher.begin().exited(a, c).end(), "should not match exited [A, C]");
+  ok(!matcher.begin().exited('A', 'C').end(), "should not match exited ['A', 'C']");
+  ok(!matcher.begin().exited(a).exited(c).end(), "should not match exited A, exited C");
+});
+
+test("match against sequence exited A, entered B", function() {
+  monitor.pushExitedState(a);
+  monitor.pushEnteredState(b);
+  
+  var matcher = monitor.matchSequence();
+  
+  ok(matcher.begin().exited(a).entered(b).end(), "should match exited A, entered B");
+  ok(matcher.begin().exited('A').entered('B').end(), "should match exited 'A', entered 'B'");
+  ok(!matcher.begin().entered(a).exited(a).end(), "should not match entered A, exited B");
+  ok(!matcher.begin().entered('A').exited('B').end(), "should not match entered 'A', exited 'B'");
+  ok(!matcher.begin().exited(a).entered(c).end(), "should not match exited A, entered C");
+  ok(!matcher.begin().exited(a).entered(b, c).end(), "should not match exited A, entered [B, C]");
+  ok(!matcher.begin().exited(a).entered(b).entered(c).end(), "should not match exited A, entered B, entered C");
+  ok(!matcher.begin().exited(a).entered(b).exited(c).end(), "should not match exited A, entered B, exited C");
+});
+
+test("match against sequence seq(enter A), seq(enter B)", function() {
+  monitor.pushEnteredState(a);
+  monitor.pushEnteredState(b);
+  
+  var matcher = monitor.matchSequence();
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+    .endSequence()
+    .beginSequence()
+      .entered(b)
+    .endSequence()
+  .end();
+  
+  ok(matcher.get('match'), "should match seq(entered A), seq(entered B)");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+      .entered(b)
+    .endSequence()
+  .end();
+  
+  ok(matcher.get('match'), "should match seq(entered A, entered B)");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+      .entered(b)
+    .endSequence()
+  .end();
+  
+  ok(matcher.get('match'), "should match seq(entered A, entered B)");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a, b)
+    .endSequence()
+  .end();
+  
+  ok(matcher.get('match'), "should match seq(entered [A, B]");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+    .endSequence()
+  .end();
+  
+  ok(!matcher.get('match'), "should not match seq(entered A)");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+    .endSequence()
+    .beginSequence()
+      .entered(c)
+    .endSequence()
+  .end();
+  
+  ok(!matcher.get('match'), "should not match seq(entered A), seq(entered C)");
+  
+  matcher.begin()
+    .beginSequence()
+      .entered(a)
+    .endSequence()
+    .beginSequence()
+      .entered(b)
+    .endSequence()
+    .beginSequence()
+      .entered(c)
+    .endSequence()
+  .end();
+  
+  ok(!matcher.get('match'), "should not match seq(entered A), seq(entered B), seq(entered C)");
+});
+
+test("match against sequence con(entered A)", function() {
+  monitor.pushEnteredState(a);
+  
+  var matcher = monitor.matchSequence();
+  
+  matcher.begin()
+     .beginConcurrent()
+       .entered(a)
+     .endConcurrent()
+   .end();
+   
+   ok(matcher.get('match'), "should match con(entered A)");
+   
+   matcher.begin()
+    .beginConcurrent()
+      .beginSequence()
+        .entered(a)
+      .endSequence()
+    .endConcurrent()
+  .end();
+
+  ok(matcher.get('match'), "should match con(seq(entered A))");
+   
+  matcher.begin()
+    .beginConcurrent()
+      .entered(b)
+    .endConcurrent()
+  .end();
+   
+  ok(!matcher.get('match'), "should match con(entered B)");
+   
+  matcher.begin()
+    .beginConcurrent()
+      .exited(a)
+    .endConcurrent()
+  .end();
+   
+  ok(!matcher.get('match'), "should match con(exited B)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a)
+      .entered(b)
+    .endConcurrent()
+  .end();
+  
+  ok(!matcher.get('match'), "should not match con(entered A, entered B)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(b)
+      .entered(a)
+    .endConcurrent()
+  .end();
+  
+  ok(!matcher.get('match'), "should not match con(entered B, entered A)");
+});
+
+test("match against sequence con(entered A entered B)", function() {
+  monitor.pushEnteredState(a);
+  monitor.pushEnteredState(b);
+  
+  var matcher = monitor.matchSequence();
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a)
+      .entered(b)
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(entered A, entered B)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(b)
+      .entered(a)
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(entered B, entered A)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .beginSequence()
+        .entered(a)
+      .endSequence()
+      .entered(b)
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(seq(entered A), entered B)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .beginSequence()
+        .entered(a)
+      .endSequence()
+      .beginSequence()
+        .entered(b)
+      .endSequence()
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(seq(entered A), seq(entered B))");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a, b)
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(entered [A, B])");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .beginSequence()
+        .entered(a)
+        .entered(b)
+      .endSequence()
+    .endConcurrent()
+  .end();
+   
+  ok(matcher.get('match'), "should match con(entered [A, B])");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a)
+    .endConcurrent()
+  .end();
+   
+  ok(!matcher.get('match'), "should not match con(entered A])");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a)
+      .entered(c)
+    .endConcurrent()
+  .end();
+   
+  ok(!matcher.get('match'), "should not match con(entered A, entered C)");
+  
+  matcher.begin()
+    .beginConcurrent()
+      .entered(a)
+      .entered(b)
+      .entered(c)
+    .endConcurrent()
+  .end();
+   
+  ok(!matcher.get('match'), "should not match con(entered A, entered B, entered C)");
+   
+});
+
+test("match against sequence con(entered A entered B)", function() {
+  monitor.pushEnteredState(a);
+  monitor.pushEnteredState(b);
+  monitor.pushEnteredState(x);
+  monitor.pushEnteredState(m);
+  monitor.pushEnteredState(n);
+  monitor.pushEnteredState(y);
+  monitor.pushEnteredState(o);
+  monitor.pushEnteredState(p);
+  monitor.pushEnteredState(c);
+  
+  var matcher = monitor.matchSequence();
+  
+  matcher.begin()
+    .entered(a)
+    .entered(b)
+    .beginConcurrent()
+      .beginSequence()
+        .entered(x, m, n)
+      .endSequence()
+      .beginSequence()
+        .entered(y, o, p)
+      .endSequence()
+    .endConcurrent()
+    .entered(c)
+  .end();
+  
+  ok(matcher.get('match'), 
+    "should match entered A, entered B, con(seq(entered [X, M, N]), seq(entered [Y, O, P])) entered C)");
+    
+  matcher.begin()
+    .entered(a)
+    .entered(b)
+    .beginConcurrent()
+      .beginSequence()
+        .entered(y, o, p)
+      .endSequence()
+      .beginSequence()
+        .entered(x, m, n)
+      .endSequence()
+    .endConcurrent()
+    .entered(c)
+  .end();
+
+  ok(matcher.get('match'), 
+    "should match entered A, entered B, con(seq(entered [Y, O, P]), seq(entered [X, M, N])) entered C)");
+    
+  matcher.begin()
+    .entered(a)
+    .entered(b)
+    .beginConcurrent()
+      .beginSequence()
+        .entered(x, m)
+      .endSequence()
+      .beginSequence()
+        .entered(y, o, p)
+      .endSequence()
+    .endConcurrent()
+    .entered(c)
+  .end();
+
+  ok(!matcher.get('match'), 
+    "should not match entered A, entered B, con(seq(entered [X, M]), seq(entered [Y, O, P])) entered C)");
+    
+  matcher.begin()
+    .entered(a)
+    .entered(b)
+    .beginConcurrent()
+      .beginSequence()
+        .entered(x, m, n)
+      .endSequence()
+      .beginSequence()
+        .entered(y, o)
+      .endSequence()
+    .endConcurrent()
+    .entered(c)
+  .end();
+
+  ok(!matcher.get('match'), 
+    "should not match entered A, entered B, con(seq(entered [X, M]), seq(entered [Y, O])) entered C)");
+    
+  matcher.begin()
+    .entered(a)
+    .entered(b)
+    .beginConcurrent()
+      .beginSequence()
+        .entered(x, m, n)
+      .endSequence()
+      .beginSequence()
+        .entered(y, o, p)
+      .endSequence()
+      .entered(e)
+    .endConcurrent()
+    .entered(c)
+  .end();
+
+  ok(!matcher.get('match'), 
+    "should not match entered A, entered B, con(seq(entered [X, M, N]), seq(entered [Y, O, P]), entered E) entered C)");
+  
+});