text: // Copyright 2008 The Closure Library Authors. All Rights Reserved.
  //
  // Licensed under the Apache License, Version 2.0 (the "License");
  // you may not use this file except in compliance with the License.
  // You may obtain a copy of the License at
  //
  //      http://www.apache.org/licenses/LICENSE-2.0
  //
  // Unless required by applicable law or agreed to in writing, software
  // distributed under the License is distributed on an "AS-IS" BASIS,
  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  // See the License for the specific language governing permissions and
  // limitations under the License.
  goog.provide("goog.async.ConditionalDelayTest")
  goog.setTestOnly("goog.async.ConditionalDelayTest")
  
  goog.require("goog.async.ConditionalDelay")
  goog.require("goog.testing.MockClock")
  goog.require("goog.testing.jsunit")
  
  var invoked = false
  var delay = null
  var clock = null
  var returnValue = true
  var onSuccessCalled = false
  var onFailureCalled = false
  
  function callback() {
    invoked = true
    return returnValue
  }
  
  function setUp() {
    clock = new goog.testing.MockClock(true)
    invoked = false
    returnValue = true
    onSuccessCalled = false
    onFailureCalled = false
    delay = new goog.async.ConditionalDelay(callback)
    delay.onSuccess = function() {
      onSuccessCalled = true
    }
    delay.onFailure = function() {
      onFailureCalled = true
    }
  }
  
  function tearDown() {
    clock.dispose()
    delay.dispose()
  }
  
  function testDelay() {
    delay.start(200, 200)
    assertFalse(invoked)
  
    clock.tick(100)
    assertFalse(invoked)
  
    clock.tick(100)
    assertTrue(invoked)
  }
  
  function testStop() {
    delay.start(200, 500)
    assertTrue(delay.isActive())
  
    clock.tick(100)
    assertFalse(invoked)
  
    delay.stop()
    clock.tick(100)
    assertFalse(invoked)
  
    assertFalse(delay.isActive())
  }
  
  function testIsActive() {
    assertFalse(delay.isActive())
    delay.start(200, 200)
    assertTrue(delay.isActive())
    clock.tick(200)
    assertFalse(delay.isActive())
  }
  
  function testRestart() {
    delay.start(200, 50000)
    clock.tick(100)
  
    delay.stop()
    assertFalse(invoked)
  
    delay.start(200, 50000)
    clock.tick(199)
    assertFalse(invoked)
  
    clock.tick(1)
    assertTrue(invoked)
  
    invoked = false
    delay.start(200, 200)
    clock.tick(200)
    assertTrue(invoked)
  
    assertFalse(delay.isActive())
  }
  
  function testDispose() {
    delay.start(200, 200)
    delay.dispose()
    assertTrue(delay.isDisposed())
  
    clock.tick(500)
    assertFalse(invoked)
  }
  
  function testConditionalDelay_Success() {
    returnValue = false
    delay.start(100, 300)
  
    clock.tick(99)
    assertFalse(invoked)
    clock.tick(1)
    assertTrue(invoked)
  
    assertTrue(delay.isActive())
    assertFalse(delay.isDone())
    assertFalse(onSuccessCalled)
    assertFalse(onFailureCalled)
  
    returnValue = true
  
    invoked = false
    clock.tick(100)
    assertTrue(invoked)
  
    assertFalse(delay.isActive())
    assertTrue(delay.isDone())
    assertTrue(onSuccessCalled)
    assertFalse(onFailureCalled)
  
    invoked = false
    clock.tick(200)
    assertFalse(invoked)
  }
  
  function testConditionalDelay_Failure() {
    returnValue = false
    delay.start(100, 300)
  
    clock.tick(99)
    assertFalse(invoked)
    clock.tick(1)
    assertTrue(invoked)
  
    assertTrue(delay.isActive())
    assertFalse(delay.isDone())
    assertFalse(onSuccessCalled)
    assertFalse(onFailureCalled)
  
    invoked = false
    clock.tick(100)
    assertTrue(invoked)
    assertFalse(onSuccessCalled)
    assertFalse(onFailureCalled)
  
    invoked = false
    clock.tick(90)
    assertFalse(invoked)
    clock.tick(10)
    assertTrue(invoked)
  
    assertFalse(delay.isActive())
    assertFalse(delay.isDone())
    assertFalse(onSuccessCalled)
    assertTrue(onFailureCalled)
  }
  
  function testInfiniteDelay() {
    returnValue = false
    delay.start(100, -1)
  
    // Test in a big enough loop.
    for (var i = 0; i < 1000; ++i) {
      clock.tick(80)
      assertTrue(delay.isActive())
      assertFalse(delay.isDone())
      assertFalse(onSuccessCalled)
      assertFalse(onFailureCalled)
    }
  
    delay.stop()
    assertFalse(delay.isActive())
    assertFalse(delay.isDone())
    assertFalse(onSuccessCalled)
    assertFalse(onFailureCalled)
  }
  
  function testCallbackScope() {
    var callbackCalled = false
    var scopeObject = {}
    function internalCallback() {
      assertEquals(this, scopeObject)
      callbackCalled = true
      return true
    }
    delay = new goog.async.ConditionalDelay(internalCallback, scopeObject)
    delay.start(200, 200)
    clock.tick(201)
    assertTrue(callbackCalled)
  }
  