sproutcore 1.9.2 → 1.10.0.rc.1

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/view/updateLayer.js

@@ -6,143 +6,81 @@
 
 /*global module test equals context ok same */
 
-// NOTE: This file tests both updateLayer() and the related methods that 
+// NOTE: This file tests both updateLayer() and the related methods that
 // will trigger it.
 
 // ..........................................................
 // TEST: updateLayer()
-// 
+//
 module("SC.View#updateLayer");
 
-test("invokes renderLayerSettings() and then updates layer element", function() {
+test("invokes applyAttributesToContext() and then updates layer element", function() {
   var layer = document.createElement('div');
 
   var times = 0;
   var view = SC.View.create({
-    _renderLayerSettings: function() {
+    applyAttributesToContext: function() {
       times++;
       this.$().addClass('did-update-' + times);
     }
   });
   view.createLayer();
-  view.updateLayer();
-  ok(view.$().attr('class').indexOf('did-update-2')>=0, 'has class name added by prepareContext()');
+  view.updateLayer(true);
+  ok(view.$().attr('class').indexOf('did-update-2')>=0, 'has class name added by render()');
+
+  // Clean up.
+  layer = null;
+  view.destroy();
 });
 
 // ..........................................................
 // TEST: updateLayerIfNeeded()
-// 
+//
 var view, callCount ;
 module("SC.View#updateLayerIfNeeded", {
   setup: function() {
-    // setup a fake view class so that updateLayerIfNeeded() will call
-    // updateLayer() if needed.  updateLayer() is faked to isolate test
     view = SC.View.create({
-      isVisibleInWindow: YES,
-      updateLayer: function() { callCount++; }
+      isVisible: false,
+      _executeDoUpdateContent: function() {
+        callCount++;
+      }
     });
     callCount = 0 ;
-    
+
     view.createLayer();
-    view.set("layerNeedsUpdate", YES);
+    view._doAttach(document.body);
+  },
+
+  teardown: function () {
+    // Clean up.
+    view.destroy();
+    view = null;
   }
-  
-});
 
-test("does not call updateLayer if layerNeedsUpdate is NO", function() {
-  view.set('layerNeedsUpdate', NO);
-  view.updateLayerIfNeeded();
-  equals(callCount, 0, 'updateLayer did NOT run');
 });
 
-test("does not call updateLayer if isVisibleInWindow is NO", function() {
-  view.set('isVisibleInWindow', NO);
+test("does not call _executeDoUpdateContent if not in shown state", function() {
   view.updateLayerIfNeeded();
-  equals(callCount, 0, 'updateLayer did NOT run');
+  equals(callCount, 0, '_executeDoUpdateContent did NOT run');
 });
 
-test("does call updateLayer() if isVisible & layerNeedsUpdate", function() {
+test("does call _executeDoUpdateContent if in shown state", function() {
+  view.set('isVisible', true);
   equals(view.get('isVisibleInWindow'), YES, 'precond - isVisibleInWindow');
-  equals(view.get('layerNeedsUpdate'), YES, 'precond - layerNeedsUpdate');
-  
-  view.updateLayerIfNeeded();
-  ok(callCount > 0, 'updateLayer() did run');
-});
 
-test("resets layerNeedsUpdate to NO if called", function() {
-  equals(view.get('layerNeedsUpdate'), YES, 'precond - layerNeedsUpdate');
   view.updateLayerIfNeeded();
-  equals(view.get('layerNeedsUpdate'), NO, 'layerNeedsUpdate reset to NO');
+  ok(callCount > 0, '_executeDoUpdateContent() did run');
 });
 
 test("returns receiver", function() {
   equals(view.updateLayerIfNeeded(), view, 'returns receiver');
 });
 
-test("only runs updateLayer() once if called multiple times (since layerNeedsUpdate is set to NO)", function() {
+test("only runs _executeDoUpdateContent once if called multiple times (since layerNeedsUpdate is set to NO)", function() {
   callCount = 0;
-  view.updateLayerIfNeeded().updateLayerIfNeeded().updateLayerIfNeeded();
-  equals(callCount, 1, 'updateLayer() called only once');
-});
-
-// ..........................................................
-// TEST: layerNeedsUpdate auto-trigger
-// 
-module("SC.View#layerNeedsUpdate auto-triggers", {
-  setup: function() {
-    // use fake method to isolate call...
-    view = SC.View.create({
-      updateLayerIfNeeded: function() { callCount++; }
-    });
-    callCount = 0;
-  }
-});
-
-test("setting layerNeedsUpdate calls updateLayerIfNeeded at end of runloop", function() {
-  SC.RunLoop.begin();
-  view.set('layerNeedsUpdate', YES);
-  SC.RunLoop.end();
-  
-  equals(callCount, 1, 'updateLayerIfNeeded did run');  
-});
-
-test("setting & resetting only triggers updateLayerIfNeeded once per runloop", function() {
-  SC.RunLoop.begin();
-  view.set('layerNeedsUpdate', YES)
-      .set('layerNeedsUpdate', NO)
-      .set('layerNeedsUpdate', YES);
-  SC.RunLoop.end();
-  
-  equals(callCount, 1, 'updateLayerIfNeeded did run');  
-});
-
-// ..........................................................
-// INTEGRATION SCENARIOS
-// 
-
-module("SC.View#updateLayer - integration");
-
-test("layerNeedsUpdate actually triggers updateLayer", function() {
-  var callCount = 0 ;
-  var layer = document.createElement('div');
-  var view = SC.View.create({
-    isVisibleInWindow: YES,
-    updateLayer: function() { callCount++; }
+  view.set('isVisible', true);
+  SC.run(function () {
+    view.displayDidChange().displayDidChange().displayDidChange();
   });
-  view.createLayer();
-  
-  SC.RunLoop.begin();
-  view.set('layerNeedsUpdate', YES);
-  SC.RunLoop.end();
-  
-  equals(callCount, 1, 'updateLayer did run b/c layerNeedsUpdate is YES');
-  callCount = 0 ;
-  
-  SC.RunLoop.begin();
-  view.set('layerNeedsUpdate', YES);
-  view.set('layerNeedsUpdate', NO);
-  SC.RunLoop.end();
-  
-  equals(callCount, 0, 'updateLayer did NOT run b/c layerNeedsUpdate is NO');
+  equals(callCount, 1, '_executeDoUpdateContent() called only once');
 });
-

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/view/viewDidResize.js

@@ -8,25 +8,25 @@
 
 // ..........................................................
 // viewDidResize()
-// 
+//
 module("SC.View#viewDidResize");
 
 test("invokes parentViewDidResize on all child views", function() {
   var callCount = 0 ;
-  var ChildView = SC.View.extend({ 
-    parentViewDidResize: function() { callCount++; } 
+  var ChildView = SC.View.extend({
+    parentViewDidResize: function() { callCount++; }
   });
-  
+
   var view = SC.View.create({
-    childViews: [ChildView, ChildView, ChildView]    
+    childViews: [ChildView, ChildView, ChildView]
   });
-  
+
   // now test...
   SC.run(function() { view.viewDidResize(); });
   equals(callCount, 3, 'should invoke parentViewDidResize() on all children');
 });
 
-test("triggers whenever layout property is changed", function() {
+test("parentViewDidResize should only be called when the parent's layout property changes in a manner that may affect child views.", function() {
   var callCount = 0 ;
   var view = SC.View.create({
     // use the callback below to detect when viewDidResize is icalled.
@@ -34,9 +34,53 @@ test("triggers whenever layout property is changed", function() {
       parentViewDidResize: function() { callCount++; }
     })]
   });
-  
-  SC.run(function() { view.set('layout', { top: 10, left: 20, height: 50, width: 40 }); });
-  equals(callCount, 1, 'viewDidResize should invoke once');
+
+  SC.run(function () { view.set('layout', { top: 10, left: 20, height: 50, width: 40 }); });
+  equals(callCount, 1, 'parentViewDidResize should invoke once');
+
+  SC.run(function () { view.adjust('top', 0); });
+  equals(callCount, 1, 'parentViewDidResize should invoke once');
+
+  SC.run(function () { view.adjust('height', 60); });
+  equals(callCount, 2, 'parentViewDidResize should invoke twice');
+
+  // This is tricky, if the height increases, but the same size border is added, the effective height/width is unchanged.
+  SC.run(function () { view.adjust({'height': 70, 'borderTop': 10 }); });
+  equals(callCount, 2, 'parentViewDidResize should invoke twice');
+});
+
+test("The view's frame should only notify changes when its layout changes if the effective size or position actually change.", function () {
+  var view2 = SC.View.create({
+      frameCallCount: 0,
+      frameDidChange: function() {
+        this.frameCallCount++;
+      }.observes('frame'),
+      viewDidResize: CoreTest.stub('viewDidResize', SC.View.prototype.viewDidResize)
+    }),
+    view1 = SC.View.create({
+      childViews: [view2],
+      layout: { width: 200, height: 200 }
+    });
+
+  SC.run(function () { view2.set('layout', { height: 50, width: 50 }); });
+  equals(view2.get('frameCallCount'), 1, 'frame should have notified changing once.');
+
+  SC.run(function () { view2.adjust('top', 0); });
+  equals(view2.get('frameCallCount'), 2, 'frame should have notified changing once.');
+
+  SC.run(function () { view2.adjust('height', 100); });
+  equals(view2.get('frameCallCount'), 3, 'frame should have notified changing twice.');
+
+  // Tricky.
+  SC.run(function () { view2.adjust({ 'height': 110, 'borderTop': 10, 'top': -10 }); });
+  equals(view2.get('frameCallCount'), 4, 'frame should have notified changing twice.');
+
+  SC.run(function () { view2.adjust('width', null); });
+  equals(view2.get('frameCallCount'), 5, 'frame should have notified changing thrice.');
+
+  // Tricky.
+  SC.run(function () { view2.adjust('width', 200); });
+  equals(view2.get('frameCallCount'), 6, 'frame should have notified changing thrice.');
 });
 
 test("making sure that the frame value is correct inside viewDidResize()", function() {
@@ -45,14 +89,14 @@ test("making sure that the frame value is correct inside viewDidResize()", funct
   // the method itself, we'll cache a global reference to the then-current
   // value and test it later.
   var cachedFrame;
-  
+
   var view = SC.View.create({
-    
+
     layout: { left:0, top:0, width:400, height:400 },
-    
+
     viewDidResize: function() {
         sc_super();
-        
+
         // Set a global reference to my frame at this point so that we can
         // test for the correct value later.
         cachedFrame = this.get('frame');
@@ -65,7 +109,7 @@ test("making sure that the frame value is correct inside viewDidResize()", funct
   // after the resize, we can verify that the cache invalidation logic is
   // working correctly.
   var originalFrame = view.get('frame');
-  
+
   SC.RunLoop.begin();
   view.adjust('height', 314);
   SC.RunLoop.end();
@@ -79,86 +123,90 @@ test("making sure that the frame value is correct inside viewDidResize()", funct
 
 // ..........................................................
 // parentViewDidResize()
-// 
+//
 module("SC.View#parentViewDidResize");
 
-test("Optimized notify on frame and optimized cascade call to child views.", function() {
+test("When parentViewDidResize is called on a view, it should only notify on frame and cascade the call to child views if it will be affected by the parent's resize.", function() {
   var view = SC.View.create({
-    // instrument...
-    frameCallCount: 0,
-    frameDidChange: function() {
-      this.frameCallCount++;
-    }.observes('frame'),
-    viewDidResize: CoreTest.stub('viewDidResize', SC.View.prototype.viewDidResize)
-  });
+      // instrument...
+      frameCallCount: 0,
+      frameDidChange: function() {
+        this.frameCallCount++;
+      }.observes('frame'),
+      viewDidResize: CoreTest.stub('viewDidResize', SC.View.prototype.viewDidResize)
+    }),
+    parentView = SC.View.create({
+      childViews: [view],
+      layout: { height: 100, width: 100 }
+    });
 
   // try with fixed layout
   view.set('layout', { top: 10, left: 10, height: 10, width: 10 });
   view.viewDidResize.reset(); view.frameCallCount = 0;
-  view.parentViewDidResize();
+  parentView.adjust({ width: 90, height: 90 });
   view.viewDidResize.expect(0);
   equals(view.frameCallCount, 0, 'should not notify frame changed when isFixedPosition: %@ and isFixedSize: %@'.fmt(view.get('isFixedPosition'), view.get('isFixedSize')));
 
   // try with flexible height
   view.set('layout', { top: 10, left: 10, bottom: 10, width: 10 });
   view.viewDidResize.reset(); view.frameCallCount = 0;
-  view.parentViewDidResize();
+  parentView.adjust({ width: 80, height: 80 });
   view.viewDidResize.expect(1);
   equals(view.frameCallCount, 1, 'should notify frame changed when isFixedPosition: %@ and isFixedSize: %@'.fmt(view.get('isFixedPosition'), view.get('isFixedSize')));
 
   // try with flexible width
   view.set('layout', { top: 10, left: 10, height: 10, right: 10 });
   view.viewDidResize.reset(); view.frameCallCount = 0;
-  view.parentViewDidResize();
+  parentView.adjust({ width: 70, height: 70 });
   view.viewDidResize.expect(1);
   equals(view.frameCallCount, 1, 'should notify frame changed when isFixedPosition: %@ and isFixedSize: %@'.fmt(view.get('isFixedPosition'), view.get('isFixedSize')));
 
   // try with right align
   view.set('layout', { top: 10, right: 10, height: 10, width: 10 });
   view.viewDidResize.reset(); view.frameCallCount = 0;
-  view.parentViewDidResize();
+  parentView.adjust({ width: 60, height: 60 });
   view.viewDidResize.expect(0);
   equals(view.frameCallCount, 1, 'should notify frame changed when isFixedPosition: %@ and isFixedSize: %@'.fmt(view.get('isFixedPosition'), view.get('isFixedSize')));
 
   // try with bottom align
   view.set('layout', { top: 10, bottom: 10, height: 10, width: 10 });
   view.viewDidResize.reset(); view.frameCallCount = 0;
-  view.parentViewDidResize();
+  parentView.adjust({ width: 50, height: 50 });
   view.viewDidResize.expect(0);
   equals(view.frameCallCount, 1, 'should notify frame changed when isFixedPosition: %@ and isFixedSize: %@'.fmt(view.get('isFixedPosition'), view.get('isFixedSize')));
 
   // try with center horizontal align
   view.set('layout', { centerX: 10, top: 10, height: 10, width: 10 });
   view.viewDidResize.reset(); view.frameCallCount = 0;
-  view.parentViewDidResize();
+  parentView.adjust({ width: 40, height: 40 });
   view.viewDidResize.expect(0);
   equals(view.frameCallCount, 1, 'should notify frame changed when isFixedPosition: %@ and isFixedSize: %@'.fmt(view.get('isFixedPosition'), view.get('isFixedSize')));
 
   // try with center vertical align
   view.set('layout', { left: 10, centerY: 10, height: 10, width: 10 });
   view.viewDidResize.reset(); view.frameCallCount = 0;
-  view.parentViewDidResize();
+  parentView.adjust({ width: 30, height: 30 });
   view.viewDidResize.expect(0);
   equals(view.frameCallCount, 1, 'should notify frame changed when isFixedPosition: %@ and isFixedSize: %@'.fmt(view.get('isFixedPosition'), view.get('isFixedSize')));
 });
 
 // ..........................................................
 // beginLiveResize()
-// 
+//
 module("SC.View#beginLiveResize");
 
 test("invokes willBeginLiveResize on receiver and any child views that implement it", function() {
-  var callCount = 0;  
+  var callCount = 0;
   var ChildView = SC.View.extend({
     willBeginLiveResize: function() { callCount++ ;}
   });
-  
+
   var view = ChildView.create({ // <-- has callback
     childViews: [SC.View.extend({ // <-- this does not implement callback
       childViews: [ChildView] // <-- has callback
     })]
   });
-  
+
   callCount = 0 ;
   view.beginLiveResize();
   equals(callCount, 2, 'should invoke willBeginLiveResize when implemented');
@@ -171,21 +219,21 @@ test("returns receiver", function() {
 
 // ..........................................................
 // endLiveResize()
-// 
+//
 module("SC.View#endLiveResize");
 
 test("invokes didEndLiveResize on receiver and any child views that implement it", function() {
-  var callCount = 0;  
+  var callCount = 0;
   var ChildView = SC.View.extend({
     didEndLiveResize: function() { callCount++; }
   });
-  
+
   var view = ChildView.create({ // <-- has callback
     childViews: [SC.View.extend({ // <-- this does not implement callback
       childViews: [ChildView] // <-- has callback
     })]
   });
-  
+
   callCount = 0 ;
   view.endLiveResize();
   equals(callCount, 2, 'should invoke didEndLiveResize when implemented');

data/lib/frameworks/sproutcore/frameworks/core_foundation/tests/views/view/view_states_test.js

@@ -0,0 +1,684 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/*global module, test, equals,ok */
+
+var parentView;
+
+/** Test the SC.View states. */
+module("SC.View States", {
+
+  setup: function () {
+    parentView = SC.View.create();
+  },
+
+  teardown: function () {
+    parentView.destroy();
+    parentView = null;
+  }
+
+});
+
+/**
+  Test the state, in particular supported actions.
+  */
+test("Test unrendered state.", function () {
+  var handled,
+    view = SC.View.create();
+
+  // Test expected state of the view.
+  equals(view.viewState, SC.CoreView.UNRENDERED, "A newly created view should be in the state");
+  ok(!view.get('isAttached'), "isAttached should be false");
+  ok(!view.get('_isRendered'), "_isRendered should be false");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+
+  // _doAttach(document.body)
+  // _doDestroyLayer()
+  // _doDetach()
+  // _doHide()
+  // _doRender()
+  // _doShow()
+  // _doUpdateContent()
+  // _doUpdateLayout()
+
+  // UNHANDLED ACTIONS
+  handled = view._doAttach(document.body);
+  ok(!handled, "Calling _doAttach(document.body) should not be handled");
+  equals(view.viewState, SC.CoreView.UNRENDERED, "Calling _doAttach(document.body) doesn't change state");
+
+  handled = view._doDestroyLayer();
+  ok(!handled, "Calling _doDestroyLayer() should not be handled");
+  equals(view.viewState, SC.CoreView.UNRENDERED, "Calling _doDestroyLayer() doesn't change state");
+
+  handled = view._doDetach();
+  ok(!handled, "Calling _doDetach() should not be handled");
+  equals(view.viewState, SC.CoreView.UNRENDERED, "Calling _doDetach() doesn't change state");
+
+  handled = view._doHide();
+  ok(!handled, "Calling _doHide() should not be handled");
+  equals(view.viewState, SC.CoreView.UNRENDERED, "Calling _doHide() doesn't change state");
+
+  handled = view._doUpdateContent();
+  ok(!handled, "Calling _doUpdateContent() should not be handled");
+  equals(view.viewState, SC.CoreView.UNRENDERED, "Calling _doUpdateContent() doesn't change state");
+
+  handled = view._doUpdateLayout();
+  ok(!handled, "Calling _doUpdateLayout() should not be handled");
+  equals(view.viewState, SC.CoreView.UNRENDERED, "Calling _doUpdateLayout() doesn't change state");
+
+
+  // HANDLED ACTIONS
+
+  handled = view._doShow();
+  ok(handled, "Calling _doShow() should be handled");
+  equals(view.viewState, SC.CoreView.UNRENDERED, "Calling _doShow() doesn't change state");
+
+  handled = view._doRender();
+  ok(handled, "Calling _doRender() should be handled");
+  equals(view.viewState, SC.CoreView.UNATTACHED, "Calling _doRender() changes state");
+
+
+  // CLEAN UP
+  view.destroy();
+});
+
+/**
+  Test the state, in particular supported actions.
+  */
+test("Test unattached state.", function () {
+  var handled,
+    view = SC.View.create();
+
+  // Test expected state of the view.
+  view._doRender();
+  equals(view.viewState, SC.CoreView.UNATTACHED, "A newly created view that is rendered should be in the state");
+  ok(!view.get('isAttached'), "isAttached should be false");
+  ok(view.get('_isRendered'), "_isRendered should be true");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+
+  // _doAttach(document.body)
+  // _doDestroyLayer()
+  // _doDetach()
+  // _doHide()
+  // _doRender()
+  // _doShow()
+  // _doUpdateContent()
+  // _doUpdateLayout()
+
+  // UNHANDLED ACTIONS
+  handled = view._doDetach();
+  ok(!handled, "Calling _doDetach() should not be handled");
+  equals(view.viewState, SC.CoreView.UNATTACHED, "Calling _doDetach() doesn't change state");
+
+  handled = view._doRender();
+  ok(!handled, "Calling _doRender() should not be handled");
+  equals(view.viewState, SC.CoreView.UNATTACHED, "Calling _doRender() doesn't change state");
+
+
+  // HANDLED ACTIONS
+
+  handled = view._doHide();
+  ok(handled, "Calling _doHide() should be handled");
+  equals(view.viewState, SC.CoreView.UNATTACHED, "Calling _doHide() doesn't change state");
+
+  handled = view._doShow();
+  ok(handled, "Calling _doShow() should be handled");
+  equals(view.viewState, SC.CoreView.UNATTACHED, "Calling _doShow() doesn't change state");
+
+  handled = view._doAttach(document.body);
+  ok(handled, "Calling _doAttach(document.body) should be handled");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "Calling _doAttach(document.body) changes state");
+
+  // Reset
+  view.destroy();
+  view = SC.View.create();
+  view._doRender();
+
+  handled = view._doDestroyLayer();
+  ok(handled, "Calling _doDestroyLayer() should be handled");
+  equals(view.viewState, SC.CoreView.UNRENDERED, "Calling _doDestroyLayer() changes state");
+
+  // Reset
+  view.destroy();
+  view = SC.View.create();
+  view._doRender();
+
+  handled = view._doUpdateContent();
+  ok(handled, "Calling _doUpdateContent() should be handled");
+  equals(view.viewState, SC.CoreView.UNATTACHED, "Calling _doUpdateContent() doesn't change state");
+
+  handled = view._doUpdateLayout();
+  ok(handled, "Calling _doUpdateLayout() should be handled");
+  equals(view.viewState, SC.CoreView.UNATTACHED, "Calling _doUpdateLayout() doesn't change state");
+
+  // Reset
+  view.destroy();
+  view = SC.View.create();
+  view._doRender();
+
+  handled = view._doAttach(document.body);
+  ok(handled, "Calling _doAttach(document.body) with unrendered orphan parentView should be handled");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "Calling _doAttach(document.body) changes state");
+
+
+  // CLEAN UP
+  view.destroy();
+});
+
+
+/**
+  Test the state, in particular supported actions.
+  */
+test("Test attached_shown state.", function () {
+  var handled,
+    view = SC.View.create();
+
+  // Test expected state of the view.
+  view._doRender();
+  view._doAttach(document.body);
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "A newly created orphan view that is rendered and attached should be in the state");
+  ok(view.get('isAttached'), "isAttached should be true");
+  ok(view.get('_isRendered'), "_isRendered should be true");
+  ok(view.get('isVisibleInWindow'), "isVisibleInWindow should be true");
+
+  // _doAttach(document.body)
+  // _doDestroyLayer()
+  // _doDetach()
+  // _doHide()
+  // _doRender()
+  // _doShow()
+  // _doUpdateContent()
+  // _doUpdateLayout()
+
+
+  // UNHANDLED ACTIONS
+  handled = view._doAttach(document.body);
+  ok(!handled, "Calling _doAttach(document.body) should not be handled");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "Calling _doAttach(document.body) doesn't change state");
+
+  handled = view._doDestroyLayer();
+  ok(!handled, "Calling _doDestroyLayer() should not be handled");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "Calling _doDestroyLayer() doesn't change state");
+
+  handled = view._doRender();
+  ok(!handled, "Calling _doRender() should not be handled");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "Calling _doRender() doesn't change state");
+
+  handled = view._doShow();
+  ok(!handled, "Calling _doShow() should not be handled");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "Calling _doShow() doesn't change state");
+
+
+  // HANDLED ACTIONS
+
+  handled = view._doUpdateContent();
+  ok(handled, "Calling _doUpdateContent() should be handled");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "Calling _doUpdateContent() doesn't change state");
+
+  handled = view._doUpdateLayout();
+  ok(handled, "Calling _doUpdateLayout() should be handled");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "Calling _doUpdateLayout() doesn't change state");
+
+  handled = view._doDetach();
+  ok(handled, "Calling _doDetach() should be handled");
+  equals(view.viewState, SC.CoreView.UNATTACHED, "Calling _doDetach() changes state");
+
+  // Reset
+  view.destroy();
+  view = SC.View.create();
+  view._doRender();
+  view._doAttach(document.body);
+
+  handled = view._doHide();
+  ok(handled, "Calling _doHide() should be handled");
+  equals(view.viewState, SC.CoreView.ATTACHED_HIDDEN, "Calling _doHide() changes state");
+
+
+  // CLEAN UP
+  view.destroy();
+});
+
+
+test("Calling destroy layer, clears the layer from all child views.",  function () {
+  var child = SC.View.create(),
+    view = SC.View.create({ childViews: [child] });
+
+  view._doAdopt(parentView);
+  parentView._doRender();
+
+  ok(parentView.get('layer'), "The parentView should have a reference to the layer.");
+  ok(view.get('layer'), "The view should have a reference to the layer.");
+  ok(child.get('layer'), "The child should have a reference to the layer.");
+
+  parentView._doDestroyLayer();
+  equals(parentView.get('layer'), null, "The parentView should not have a reference to the layer.");
+  equals(view.get('layer'), null, "The view should not have a reference to the layer.");
+  equals(child.get('layer'), null, "The child should not have a reference to the layer.");
+
+  // CLEAN UP
+  view.destroy();
+});
+
+/** Test the SC.View state propagation to child views. */
+module("SC.View Adoption", {
+
+  setup: function () {
+    parentView = SC.View.create();
+  },
+
+  teardown: function () {
+    parentView.destroy();
+    parentView = null;
+  }
+
+});
+
+
+test("Test adding a child brings that child to the same state as the parentView.", function () {
+  var child = SC.View.create(),
+    view = SC.View.create({ childViews: [child] });
+
+  // Test expected state of the view.
+  view._doAdopt(parentView);
+  equals(parentView.viewState, SC.CoreView.UNRENDERED, "A newly created parentView should be in the state");
+  equals(view.viewState, SC.CoreView.UNRENDERED, "A newly created child view of unrendered parentView should be in the state");
+  equals(child.viewState, SC.CoreView.UNRENDERED, "A newly created child view of unrendered parentView's child view should be in the state");
+  ok(!view.get('_isRendered'), "_isRendered should be false");
+  ok(!view.get('isAttached'), "isAttached should be false");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+
+  // Render the view.
+  view._doRender();
+  equals(view.viewState, SC.CoreView.UNATTACHED, "A rendered child view of unrendered parentView should be in the state");
+  equals(child.viewState, SC.CoreView.UNATTACHED_BY_PARENT, "A rendered child view of unrendered parentView's child view should be in the state");
+  ok(view.get('_isRendered'), "_isRendered should be true");
+  ok(!view.get('isAttached'), "isAttached should be false");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+
+  // Attach the view.
+  view._doAttach(document.body);
+  equals(view.viewState, SC.CoreView.UNATTACHED_BY_PARENT, "An attached child view of unrendered parentView should be in the state");
+  equals(child.viewState, SC.CoreView.UNATTACHED_BY_PARENT, "An attached child view of unrendered parentView's child view should be in the state");
+  ok(view.get('_isRendered'), "_isRendered should be true");
+  ok(!view.get('isAttached'), "isAttached should be false");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+
+  // Reset
+  view.destroy();
+  child = SC.View.create();
+  view = SC.View.create({ childViews: [child] });
+
+  parentView._doRender();
+  view._doAdopt(parentView);
+  equals(parentView.viewState, SC.CoreView.UNATTACHED, "A newly created parentView that is rendered should be in the state");
+  equals(view.viewState, SC.CoreView.UNATTACHED_BY_PARENT, "A newly created child view of unattached parentView should be in the state");
+  equals(child.viewState, SC.CoreView.UNATTACHED_BY_PARENT, "A newly created child view of unattached parentView's child view should be in the state");
+  ok(view.get('_isRendered'), "_isRendered should be true");
+  ok(!view.get('isAttached'), "isAttached should be false");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+
+  // Attach the view.
+  view._doAttach(document.body);
+  equals(view.viewState, SC.CoreView.UNATTACHED_BY_PARENT, "An attached child view of unattached parentView should be in the state");
+  equals(child.viewState, SC.CoreView.UNATTACHED_BY_PARENT, "An attached child view of unattached parentView's child view should be in the state");
+  ok(view.get('_isRendered'), "_isRendered should be true");
+  ok(!view.get('isAttached'), "isAttached should be false");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+
+  // Reset
+  view.destroy();
+  child = SC.View.create();
+  view = SC.View.create({ childViews: [child] });
+
+  parentView._doAttach(document.body);
+  view._doAdopt(parentView);
+  equals(parentView.viewState, SC.CoreView.ATTACHED_SHOWN, "A newly created parentView that is attached should be in the state");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "A newly created child view of attached parentView should be in the state");
+  equals(child.viewState, SC.CoreView.ATTACHED_SHOWN, "A child of newly created view of attached parentView should be in the state");
+  ok(view.get('_isRendered'), "_isRendered should be true");
+  ok(view.get('isAttached'), "isAttached should be true");
+  ok(view.get('isVisibleInWindow'), "isVisibleInWindow should be true");
+
+
+  // CLEAN UP
+  view.destroy();
+});
+
+
+test("Test showing and hiding parentView updates child views.", function () {
+  var handled,
+    child = SC.View.create(),
+    view = SC.View.create({ childViews: [child] });
+
+  // Test expected state of the view.
+  parentView._doRender();
+  parentView._doAttach(document.body);
+  view._doAdopt(parentView);
+  equals(parentView.viewState, SC.CoreView.ATTACHED_SHOWN, "A newly created parentView that is attached should be in the state");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "A newly created child view of unattached parentView should be in the state");
+  equals(child.viewState, SC.CoreView.ATTACHED_SHOWN, "A newly created child view of unattached parentView's child view should be in the state");
+  ok(view.get('isVisibleInWindow'), "isVisibleInWindow should be true");
+
+  // Hide the parentView.
+  parentView._doHide();
+  equals(parentView.viewState, SC.CoreView.ATTACHED_HIDDEN, "A hidden parentView that is attached should be in the state");
+  equals(view.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "A child view of attached_hidden parentView should be in the state");
+  equals(child.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "A child view of attached_hidden parentView's child view should be in the state");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+
+  // Show the parentView/hide the view.
+  handled = parentView._doShow();
+  ok(handled, "Calling _doShow() on parentView should be handled");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "Calling _doShow() on parentView changes state on view.");
+  equals(child.viewState, SC.CoreView.ATTACHED_SHOWN, "Calling _doShow() on parentView changes state on child");
+  handled = view._doHide();
+  ok(handled, "Calling _doHide() should be handled");
+  equals(view.viewState, SC.CoreView.ATTACHED_HIDDEN, "Calling _doHide() on view changes state on view");
+  equals(child.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "Calling _doHide() on view changes state on child");
+
+  // Reset
+  parentView._doHide();
+  view.destroy();
+  child = SC.View.create();
+  view = SC.View.create({ childViews: [child] });
+  view._doAdopt(parentView);
+
+  // Add child to already hidden parentView.
+  equals(view.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "A child view of attached_hidden parentView should be in the state");
+  equals(child.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "A child view of attached_hidden parentView's child view should be in the state");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+
+  // Reset
+  parentView.destroy();
+  parentView = SC.View.create();
+  parentView._doRender();
+  child = SC.View.create();
+  view = SC.View.create({ childViews: [child] });
+  view._doAdopt(parentView);
+
+  // Attach a parentView with children
+  equals(view.viewState, SC.CoreView.UNATTACHED_BY_PARENT, "A child view of unattached parentView should be in the state");
+  equals(child.viewState, SC.CoreView.UNATTACHED_BY_PARENT, "A child view of unattached parentView's child view should be in the state");
+  parentView._doAttach(document.body);
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "A child view of attached_shown parentView should be in the state");
+  equals(child.viewState, SC.CoreView.ATTACHED_SHOWN, "A child view of attached_shown parentView's child view should be in the state");
+
+  // CLEAN UP
+  view.destroy();
+});
+
+test("Test hiding with transitionHide", function () {
+  var child = SC.View.create(),
+    transitionHide = { run: function () {} },
+    view = SC.View.create({ childViews: [child] });
+
+  // Set up.
+  parentView._doRender();
+  parentView._doAttach(document.body);
+  view._doAdopt(parentView);
+
+  // Hide the parentView with transitionHide
+  parentView.set('transitionHide', transitionHide);
+  parentView._doHide();
+  ok(parentView.get('isVisibleInWindow'), "isVisibleInWindow of parentView should be false");
+  ok(view.get('isVisibleInWindow'), "isVisibleInWindow should be true");
+  ok(child.get('isVisibleInWindow'), "isVisibleInWindow of child should be true");
+  parentView.didTransitionOut(transitionHide);
+  ok(!parentView.get('isVisibleInWindow'), "isVisibleInWindow of parentView should be false after didTransitionOut");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false after didTransitionOut");
+  ok(!child.get('isVisibleInWindow'), "isVisibleInWindow of child should be false after didTransitionOut");
+
+  // CLEAN UP
+  view.destroy();
+});
+
+/** isVisible */
+var child, view;
+module("SC.View isVisible integration with shown and hidden state", {
+
+  setup: function () {
+    SC.run(function () {
+      parentView = SC.View.create();
+      parentView._doRender();
+      parentView._doAttach(document.body);
+
+      child = SC.View.create(),
+      view = SC.View.create({
+        // STUB: _executeDoUpdateContent
+        _executeDoUpdateContent: CoreTest.stub('_executeDoUpdateContent', SC.CoreView.prototype._executeDoUpdateContent),
+        // STUB: _doUpdateVisibleStyle
+        _doUpdateVisibleStyle: CoreTest.stub('_doUpdateVisibleStyle', SC.CoreView.prototype._doUpdateVisibleStyle),
+
+        childViews: [child],
+        displayProperties: ['foo'],
+        foo: false
+      });
+    });
+  },
+
+  teardown: function () {
+    view.destroy();
+    parentView.destroy();
+    parentView = null;
+  }
+
+});
+
+test("Test showing and hiding a hidden view in same run loop should not update visibility or content.", function () {
+  view._doAdopt(parentView);
+
+  SC.run(function () {
+    view.set('isVisible', false);
+  });
+
+  view._executeDoUpdateContent.expect(0);
+  view._doUpdateVisibleStyle.expect(1);
+
+  // Hide the view using isVisible.
+  SC.run(function () {
+    view.set('foo', true);
+    equals(view.viewState, SC.CoreView.ATTACHED_HIDDEN, "The view should be in the state");
+    equals(child.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "The child view should be in the state");
+
+    ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+    ok(!child.get('isVisibleInWindow'), "isVisibleInWindow of child should be false");
+
+    view.set('isVisible', true);
+    equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "The view should now be in the state");
+    equals(child.viewState, SC.CoreView.ATTACHED_SHOWN, "The child view should now be in the state");
+
+    ok(view.get('isVisibleInWindow'), "isVisibleInWindow should be true");
+    ok(child.get('isVisibleInWindow'), "isVisibleInWindow of child should be true");
+
+    view.set('isVisible', false);
+  });
+
+  view._executeDoUpdateContent.expect(0);
+  view._doUpdateVisibleStyle.expect(3);
+});
+
+test("Test hiding and showing a shown view in same run loop should not update visibility.", function () {
+  view._doAdopt(parentView);
+
+  // Hide the view using isVisible.
+  SC.run(function () {
+    view.set('foo', true);
+    view.set('isVisible', false);
+    equals(view.viewState, SC.CoreView.ATTACHED_HIDDEN, "The view should be in the state");
+    equals(child.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "The child view should be in the state");
+
+    ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+    ok(!child.get('isVisibleInWindow'), "isVisibleInWindow of child should be false");
+
+    view.set('isVisible', true);
+    equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "The view should be in the state");
+    equals(child.viewState, SC.CoreView.ATTACHED_SHOWN, "The child view should be in the state");
+
+    ok(view.get('isVisibleInWindow'), "isVisibleInWindow should be true");
+    ok(child.get('isVisibleInWindow'), "isVisibleInWindow of child should be true");
+  });
+
+  view._executeDoUpdateContent.expect(1);
+  view._doUpdateVisibleStyle.expect(2);
+});
+
+
+test("Test showing and hiding a hiding view in same run loop should not update visibility or content.", function () {
+  var transitionHide = { run: function () {} };
+
+  view._doAdopt(parentView);
+
+  view.set('transitionHide', transitionHide);
+
+  SC.run(function () {
+    view.set('foo', true);
+    view.set('isVisible', false);
+  });
+
+  // Hide the view using isVisible.
+  SC.run(function () {
+    equals(view.viewState, SC.CoreView.ATTACHED_HIDING, "The view should be in the state");
+    equals(child.viewState, SC.CoreView.ATTACHED_SHOWN, "The child view should be in the state");
+
+    ok(view.get('isVisibleInWindow'), "isVisibleInWindow should be true");
+    ok(child.get('isVisibleInWindow'), "isVisibleInWindow of child should be true");
+
+    view.set('isVisible', true);
+    equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "The view should be in the state");
+    equals(child.viewState, SC.CoreView.ATTACHED_SHOWN, "The child view should be in the state");
+
+    ok(view.get('isVisibleInWindow'), "isVisibleInWindow should be true");
+    ok(child.get('isVisibleInWindow'), "isVisibleInWindow of child should be true");
+
+    view.set('isVisible', false);
+  });
+
+  view._executeDoUpdateContent.expect(1);
+  view._doUpdateVisibleStyle.expect(0);
+});
+
+test("Test hiding and showing a showing view in same run loop should not update visibility.", function () {
+  var transitionShow = { run: function () {} };
+
+  view._doAdopt(parentView);
+
+  view.set('transitionShow', transitionShow);
+
+  SC.run(function () {
+    view.set('foo', true);
+    view.set('isVisible', false);
+  });
+
+  SC.run(function () {
+    view.set('isVisible', true);
+  });
+
+  // Hide the view using isVisible.
+  SC.run(function () {
+    equals(view.viewState, SC.CoreView.ATTACHED_SHOWING, "The view should be in the state");
+    equals(child.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "The child view should be in the state");
+
+    ok(view.get('isVisibleInWindow'), "isVisibleInWindow should be true");
+    ok(!child.get('isVisibleInWindow'), "isVisibleInWindow of child should be false");
+
+    view.set('isVisible', false);
+    equals(view.viewState, SC.CoreView.ATTACHED_HIDDEN, "The view should be in the state");
+    equals(child.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "The child view should be in the state");
+
+    ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+    ok(!child.get('isVisibleInWindow'), "isVisibleInWindow of child should be false");
+
+    view.set('isVisible', true);
+  });
+
+  view._executeDoUpdateContent.expect(1);
+  view._doUpdateVisibleStyle.expect(4);
+});
+
+
+test("Test hiding and showing an attached child view with child views.", function () {
+  view._doAdopt(parentView);
+
+  // Hide the view using isVisible.
+  SC.run(function () {
+    view.set('isVisible', false);
+  });
+
+  equals(parentView.viewState, SC.CoreView.ATTACHED_SHOWN, "The parentView view should be in the state");
+  equals(view.viewState, SC.CoreView.ATTACHED_HIDDEN, "The view should be in the state");
+  equals(child.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "The child view should be in the state");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+  ok(!child.get('isVisibleInWindow'), "isVisibleInWindow of child should be false");
+
+  // Show the view using isVisible.
+  SC.run(function () {
+    view.set('isVisible', true);
+  });
+
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "The view should be in the state");
+  equals(child.viewState, SC.CoreView.ATTACHED_SHOWN, "The child view should be in the state");
+  ok(view.get('isVisibleInWindow'), "isVisibleInWindow should now be true");
+  ok(child.get('isVisibleInWindow'), "isVisibleInWindow of child should now be true");
+});
+
+
+test("Test hiding an attached parentView view and then adding child views.", function () {
+  // Hide the parentView using isVisible and then adopting child views.
+  SC.run(function () {
+    parentView.set('isVisible', false);
+    view._doAdopt(parentView);
+  });
+
+  equals(parentView.viewState, SC.CoreView.ATTACHED_HIDDEN, "The parentView view should be in the state");
+  equals(view.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "The view should be in the state");
+  equals(child.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "The child view should be in the state");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+  ok(!child.get('isVisibleInWindow'), "isVisibleInWindow of child should be false");
+
+  // Show the parentView using isVisible.
+  SC.run(function () {
+    parentView.set('isVisible', true);
+  });
+
+  equals(parentView.viewState, SC.CoreView.ATTACHED_SHOWN, "The parentView view should be in the state");
+  equals(view.viewState, SC.CoreView.ATTACHED_SHOWN, "The view should be in the state");
+  equals(child.viewState, SC.CoreView.ATTACHED_SHOWN, "The child view should be in the state");
+  ok(view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+  ok(child.get('isVisibleInWindow'), "isVisibleInWindow of child should be false");
+});
+
+
+test("Test showing an attached parentView view while hiding the child view.", function () {
+  SC.run(function () {
+    parentView.set('isVisible', false);
+    view._doAdopt(parentView);
+
+    // Hide the view and then show the parentView using isVisible.
+    view.set('isVisible', false);
+    parentView.set('isVisible', true);
+  });
+
+  equals(parentView.viewState, SC.CoreView.ATTACHED_SHOWN, "The parentView view should be in the state");
+  equals(view.viewState, SC.CoreView.ATTACHED_HIDDEN, "The view should be in the state");
+  equals(child.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "The child view should be in the state");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+  ok(!child.get('isVisibleInWindow'), "isVisibleInWindow of child should be false");
+});
+
+
+test("Test adding a hidden child view to attached shown parentView.", function () {
+  // Hide the view with isVisible and then add to parentView.
+  SC.run(function () {
+    view.set('isVisible', false);
+    view._doAdopt(parentView);
+  });
+
+  equals(view.viewState, SC.CoreView.ATTACHED_HIDDEN, "The view should be in the state");
+  equals(child.viewState, SC.CoreView.ATTACHED_HIDDEN_BY_PARENT, "The child view should be in the state");
+  ok(!view.get('isVisibleInWindow'), "isVisibleInWindow should be false");
+  ok(!child.get('isVisibleInWindow'), "isVisibleInWindow of child should be false");
+});