2012-05-22 23:05:26 -07:00
|
|
|
'use strict';
|
|
|
|
|
|
|
|
|
|
describe('$timeout', function() {
|
|
|
|
|
|
|
|
|
|
beforeEach(module(provideLog));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should delegate functions to $browser.defer', inject(function($timeout, $browser) {
|
|
|
|
|
var counter = 0;
|
|
|
|
|
$timeout(function() { counter++; });
|
|
|
|
|
|
|
|
|
|
expect(counter).toBe(0);
|
|
|
|
|
|
|
|
|
|
$browser.defer.flush();
|
|
|
|
|
expect(counter).toBe(1);
|
|
|
|
|
|
2016-03-13 13:20:30 +01:00
|
|
|
expect(function() {$browser.defer.flush();}).toThrowError('No deferred tasks to be flushed');
|
2012-05-22 23:05:26 -07:00
|
|
|
expect(counter).toBe(1);
|
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should call $apply after each callback is executed', inject(function($timeout, $rootScope) {
|
2016-03-13 13:20:30 +01:00
|
|
|
var applySpy = spyOn($rootScope, '$apply').and.callThrough();
|
2012-05-22 23:05:26 -07:00
|
|
|
|
2015-01-22 10:48:14 -08:00
|
|
|
$timeout(noop);
|
2012-05-22 23:05:26 -07:00
|
|
|
expect(applySpy).not.toHaveBeenCalled();
|
|
|
|
|
|
|
|
|
|
$timeout.flush();
|
|
|
|
|
expect(applySpy).toHaveBeenCalledOnce();
|
|
|
|
|
|
2016-03-13 13:20:30 +01:00
|
|
|
applySpy.calls.reset();
|
2012-05-22 23:05:26 -07:00
|
|
|
|
2015-01-22 10:48:14 -08:00
|
|
|
$timeout(noop);
|
|
|
|
|
$timeout(noop);
|
2012-05-22 23:05:26 -07:00
|
|
|
$timeout.flush();
|
2016-03-13 13:20:30 +01:00
|
|
|
expect(applySpy).toHaveBeenCalledTimes(2);
|
2012-05-22 23:05:26 -07:00
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should NOT call $apply if skipApply is set to true', inject(function($timeout, $rootScope) {
|
2016-03-13 13:20:30 +01:00
|
|
|
var applySpy = spyOn($rootScope, '$apply').and.callThrough();
|
2012-05-22 23:05:26 -07:00
|
|
|
|
2015-01-22 10:48:14 -08:00
|
|
|
$timeout(noop, 12, false);
|
2012-05-22 23:05:26 -07:00
|
|
|
expect(applySpy).not.toHaveBeenCalled();
|
|
|
|
|
|
|
|
|
|
$timeout.flush();
|
|
|
|
|
expect(applySpy).not.toHaveBeenCalled();
|
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
fix($timeout/$interval): if invokeApply is false, do not use evalAsync
$evalAsync triggers a digest, and is unsuitable when it is expected that a digest should not occur.
BREAKING CHANGE
Previously, even if invokeApply was set to false, a $rootScope digest would occur during promise
resolution. This is no longer the case, as promises returned from $timeout and $interval will no
longer trigger $evalAsync (which in turn causes a $digest) if `invokeApply` is false.
Workarounds include manually triggering $scope.$apply(), or returning $q.defer().promise from a
promise callback, and resolving or rejecting it when appropriate.
var interval = $interval(function() {
if (someRequirementFulfilled) {
$interval.cancel(interval);
$scope.$apply();
}
}, 100, 0, false);
or:
var interval = $interval(function (idx) {
// make the magic happen
}, 1000, 10, false);
interval.then(function(idx) {
var deferred = $q.defer();
// do the asynchronous magic --- $evalAsync will cause a digest and cause
// bindings to update.
return deferred.promise;
});
Closes #7999
Closes #7103
2014-06-26 11:38:04 -04:00
|
|
|
it('should NOT call $evalAsync or $digest if invokeApply is set to false',
|
|
|
|
|
inject(function($timeout, $rootScope) {
|
2016-03-13 13:20:30 +01:00
|
|
|
var evalAsyncSpy = spyOn($rootScope, '$evalAsync').and.callThrough();
|
|
|
|
|
var digestSpy = spyOn($rootScope, '$digest').and.callThrough();
|
fix($timeout/$interval): if invokeApply is false, do not use evalAsync
$evalAsync triggers a digest, and is unsuitable when it is expected that a digest should not occur.
BREAKING CHANGE
Previously, even if invokeApply was set to false, a $rootScope digest would occur during promise
resolution. This is no longer the case, as promises returned from $timeout and $interval will no
longer trigger $evalAsync (which in turn causes a $digest) if `invokeApply` is false.
Workarounds include manually triggering $scope.$apply(), or returning $q.defer().promise from a
promise callback, and resolving or rejecting it when appropriate.
var interval = $interval(function() {
if (someRequirementFulfilled) {
$interval.cancel(interval);
$scope.$apply();
}
}, 100, 0, false);
or:
var interval = $interval(function (idx) {
// make the magic happen
}, 1000, 10, false);
interval.then(function(idx) {
var deferred = $q.defer();
// do the asynchronous magic --- $evalAsync will cause a digest and cause
// bindings to update.
return deferred.promise;
});
Closes #7999
Closes #7103
2014-06-26 11:38:04 -04:00
|
|
|
var fulfilledSpy = jasmine.createSpy('fulfilled');
|
|
|
|
|
|
|
|
|
|
$timeout(fulfilledSpy, 1000, false);
|
|
|
|
|
|
|
|
|
|
$timeout.flush();
|
|
|
|
|
|
|
|
|
|
expect(fulfilledSpy).toHaveBeenCalledOnce();
|
|
|
|
|
expect(evalAsyncSpy).not.toHaveBeenCalled();
|
|
|
|
|
expect(digestSpy).not.toHaveBeenCalled();
|
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
2012-05-22 23:05:26 -07:00
|
|
|
it('should allow you to specify the delay time', inject(function($timeout, $browser) {
|
|
|
|
|
var defer = spyOn($browser, 'defer');
|
|
|
|
|
$timeout(noop, 123);
|
2016-03-13 13:20:30 +01:00
|
|
|
expect(defer).toHaveBeenCalledTimes(1);
|
|
|
|
|
expect(defer.calls.mostRecent().args[1]).toEqual(123);
|
2012-05-22 23:05:26 -07:00
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should return a promise which will be resolved with return value of the timeout callback',
|
|
|
|
|
inject(function($timeout, log) {
|
|
|
|
|
var promise = $timeout(function() { log('timeout'); return 'buba'; });
|
|
|
|
|
|
|
|
|
|
promise.then(function(value) { log('promise success: ' + value); }, log.fn('promise error'));
|
|
|
|
|
expect(log).toEqual([]);
|
|
|
|
|
|
|
|
|
|
$timeout.flush();
|
|
|
|
|
expect(log).toEqual(['timeout', 'promise success: buba']);
|
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
2013-08-13 12:55:06 +01:00
|
|
|
it('should forget references to deferreds when callback called even if skipApply is true',
|
|
|
|
|
inject(function($timeout, $browser) {
|
|
|
|
|
// $browser.defer.cancel is only called on cancel if the deferred object is still referenced
|
2016-03-13 13:20:30 +01:00
|
|
|
var cancelSpy = spyOn($browser.defer, 'cancel').and.callThrough();
|
2013-08-13 12:55:06 +01:00
|
|
|
|
2015-01-22 10:48:14 -08:00
|
|
|
var promise1 = $timeout(noop, 0, false);
|
|
|
|
|
var promise2 = $timeout(noop, 100, false);
|
2013-08-13 12:55:06 +01:00
|
|
|
expect(cancelSpy).not.toHaveBeenCalled();
|
|
|
|
|
|
2013-09-05 12:01:31 -07:00
|
|
|
$timeout.flush(0);
|
2013-08-13 12:55:06 +01:00
|
|
|
|
|
|
|
|
// Promise1 deferred object should already be removed from the list and not cancellable
|
|
|
|
|
$timeout.cancel(promise1);
|
|
|
|
|
expect(cancelSpy).not.toHaveBeenCalled();
|
|
|
|
|
|
|
|
|
|
// Promise2 deferred object should not have been called and should be cancellable
|
|
|
|
|
$timeout.cancel(promise2);
|
|
|
|
|
expect(cancelSpy).toHaveBeenCalled();
|
|
|
|
|
}));
|
|
|
|
|
|
2014-10-21 15:02:07 +02:00
|
|
|
it('should allow the `fn` parameter to be optional', inject(function($timeout, log) {
|
|
|
|
|
|
|
|
|
|
$timeout().then(function(value) { log('promise success: ' + value); }, log.fn('promise error'));
|
|
|
|
|
expect(log).toEqual([]);
|
|
|
|
|
|
|
|
|
|
$timeout.flush();
|
|
|
|
|
expect(log).toEqual(['promise success: undefined']);
|
|
|
|
|
|
|
|
|
|
log.reset();
|
|
|
|
|
$timeout(1000).then(function(value) { log('promise success: ' + value); }, log.fn('promise error'));
|
|
|
|
|
expect(log).toEqual([]);
|
|
|
|
|
|
|
|
|
|
$timeout.flush(500);
|
|
|
|
|
expect(log).toEqual([]);
|
|
|
|
|
$timeout.flush(500);
|
|
|
|
|
expect(log).toEqual(['promise success: undefined']);
|
|
|
|
|
}));
|
|
|
|
|
|
2015-01-22 10:48:14 -08:00
|
|
|
it('should pass the timeout arguments in the timeout callback',
|
|
|
|
|
inject(function($timeout, $browser, log) {
|
|
|
|
|
var task1 = jasmine.createSpy('Nappa'),
|
|
|
|
|
task2 = jasmine.createSpy('Vegeta');
|
|
|
|
|
|
|
|
|
|
$timeout(task1, 9000, true, 'What does', 'the timeout', 'say about', 'its delay level');
|
|
|
|
|
expect($browser.deferredFns.length).toBe(1);
|
|
|
|
|
|
|
|
|
|
$timeout(task2, 9001, false, 'It\'s', 'over', 9000);
|
|
|
|
|
expect($browser.deferredFns.length).toBe(2);
|
|
|
|
|
|
|
|
|
|
$timeout(9000, false, 'What!', 9000).then(function(value) { log('There\'s no way that can be right! ' + value); }, log.fn('It can\'t!'));
|
|
|
|
|
expect($browser.deferredFns.length).toBe(3);
|
|
|
|
|
expect(log).toEqual([]);
|
|
|
|
|
|
|
|
|
|
$timeout.flush(0);
|
|
|
|
|
expect(task1).not.toHaveBeenCalled();
|
|
|
|
|
|
|
|
|
|
$timeout.flush(9000);
|
|
|
|
|
expect(task1).toHaveBeenCalledWith('What does', 'the timeout', 'say about', 'its delay level');
|
|
|
|
|
|
|
|
|
|
$timeout.flush(1);
|
|
|
|
|
expect(task2).toHaveBeenCalledWith('It\'s', 'over', 9000);
|
|
|
|
|
|
|
|
|
|
$timeout.flush(9000);
|
|
|
|
|
expect(log).toEqual(['There\'s no way that can be right! undefined']);
|
|
|
|
|
|
|
|
|
|
}));
|
|
|
|
|
|
2014-10-21 15:02:07 +02:00
|
|
|
|
2012-05-22 23:05:26 -07:00
|
|
|
describe('exception handling', function() {
|
|
|
|
|
|
|
|
|
|
beforeEach(module(function($exceptionHandlerProvider) {
|
|
|
|
|
$exceptionHandlerProvider.mode('log');
|
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should delegate exception to the $exceptionHandler service', inject(
|
|
|
|
|
function($timeout, $exceptionHandler) {
|
2016-08-10 12:13:14 +02:00
|
|
|
$timeout(function() { throw 'Test Error'; });
|
2012-05-22 23:05:26 -07:00
|
|
|
expect($exceptionHandler.errors).toEqual([]);
|
|
|
|
|
|
|
|
|
|
$timeout.flush();
|
2016-08-10 12:13:14 +02:00
|
|
|
expect($exceptionHandler.errors).toEqual(['Test Error', 'Possibly unhandled rejection: Test Error']);
|
2012-05-22 23:05:26 -07:00
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should call $apply even if an exception is thrown in callback', inject(
|
|
|
|
|
function($timeout, $rootScope) {
|
2016-03-13 13:20:30 +01:00
|
|
|
var applySpy = spyOn($rootScope, '$apply').and.callThrough();
|
2012-05-22 23:05:26 -07:00
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
$timeout(function() { throw 'Test Error'; });
|
2012-05-22 23:05:26 -07:00
|
|
|
expect(applySpy).not.toHaveBeenCalled();
|
|
|
|
|
|
|
|
|
|
$timeout.flush();
|
|
|
|
|
expect(applySpy).toHaveBeenCalled();
|
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should reject the timeout promise when an exception is thrown in the timeout callback',
|
|
|
|
|
inject(function($timeout, log) {
|
2016-08-10 12:13:14 +02:00
|
|
|
var promise = $timeout(function() { throw 'Some Error'; });
|
2012-05-22 23:05:26 -07:00
|
|
|
|
|
|
|
|
promise.then(log.fn('success'), function(reason) { log('error: ' + reason); });
|
|
|
|
|
$timeout.flush();
|
|
|
|
|
|
|
|
|
|
expect(log).toEqual('error: Some Error');
|
|
|
|
|
}));
|
2013-08-13 12:55:06 +01:00
|
|
|
|
|
|
|
|
|
2015-01-22 10:48:14 -08:00
|
|
|
it('should pass the timeout arguments in the timeout callback even if an exception is thrown',
|
|
|
|
|
inject(function($timeout, log) {
|
|
|
|
|
var promise1 = $timeout(function(arg) { throw arg; }, 9000, true, 'Some Arguments');
|
|
|
|
|
var promise2 = $timeout(function(arg1, args2) { throw arg1 + ' ' + args2; }, 9001, false, 'Are Meant', 'To Be Thrown');
|
|
|
|
|
|
|
|
|
|
promise1.then(log.fn('success'), function(reason) { log('error: ' + reason); });
|
|
|
|
|
promise2.then(log.fn('success'), function(reason) { log('error: ' + reason); });
|
|
|
|
|
|
|
|
|
|
$timeout.flush(0);
|
|
|
|
|
expect(log).toEqual('');
|
|
|
|
|
|
|
|
|
|
$timeout.flush(9000);
|
|
|
|
|
expect(log).toEqual('error: Some Arguments');
|
|
|
|
|
|
|
|
|
|
$timeout.flush(1);
|
|
|
|
|
expect(log).toEqual('error: Some Arguments; error: Are Meant To Be Thrown');
|
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
2013-08-13 12:55:06 +01:00
|
|
|
it('should forget references to relevant deferred even when exception is thrown',
|
|
|
|
|
inject(function($timeout, $browser) {
|
|
|
|
|
// $browser.defer.cancel is only called on cancel if the deferred object is still referenced
|
2016-03-13 13:20:30 +01:00
|
|
|
var cancelSpy = spyOn($browser.defer, 'cancel').and.callThrough();
|
2013-08-13 12:55:06 +01:00
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
var promise = $timeout(function() { throw 'Test Error'; }, 0, false);
|
2013-08-13 12:55:06 +01:00
|
|
|
$timeout.flush();
|
|
|
|
|
|
|
|
|
|
expect(cancelSpy).not.toHaveBeenCalled();
|
|
|
|
|
$timeout.cancel(promise);
|
|
|
|
|
expect(cancelSpy).not.toHaveBeenCalled();
|
|
|
|
|
}));
|
2012-05-22 23:05:26 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
describe('cancel', function() {
|
|
|
|
|
it('should cancel tasks', inject(function($timeout) {
|
|
|
|
|
var task1 = jasmine.createSpy('task1'),
|
|
|
|
|
task2 = jasmine.createSpy('task2'),
|
|
|
|
|
task3 = jasmine.createSpy('task3'),
|
2014-10-21 15:02:07 +02:00
|
|
|
task4 = jasmine.createSpy('task4'),
|
|
|
|
|
promise1, promise3, promise4;
|
2012-05-22 23:05:26 -07:00
|
|
|
|
|
|
|
|
promise1 = $timeout(task1);
|
|
|
|
|
$timeout(task2);
|
|
|
|
|
promise3 = $timeout(task3, 333);
|
2014-10-21 15:02:07 +02:00
|
|
|
promise4 = $timeout(333);
|
2016-01-01 23:40:00 +01:00
|
|
|
promise3.then(task4, noop);
|
2012-05-22 23:05:26 -07:00
|
|
|
|
|
|
|
|
$timeout.cancel(promise1);
|
2014-10-21 15:02:07 +02:00
|
|
|
$timeout.cancel(promise3);
|
|
|
|
|
$timeout.cancel(promise4);
|
2012-05-22 23:05:26 -07:00
|
|
|
$timeout.flush();
|
|
|
|
|
|
|
|
|
|
expect(task1).not.toHaveBeenCalled();
|
|
|
|
|
expect(task2).toHaveBeenCalledOnce();
|
|
|
|
|
expect(task3).not.toHaveBeenCalled();
|
2014-10-21 15:02:07 +02:00
|
|
|
expect(task4).not.toHaveBeenCalled();
|
2012-05-22 23:05:26 -07:00
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
2013-09-13 12:47:05 -07:00
|
|
|
it('should cancel the promise', inject(function($timeout, log) {
|
|
|
|
|
var promise = $timeout(noop);
|
|
|
|
|
promise.then(function(value) { log('promise success: ' + value); },
|
|
|
|
|
function(err) { log('promise error: ' + err); },
|
|
|
|
|
function(note) { log('promise update: ' + note); });
|
|
|
|
|
expect(log).toEqual([]);
|
|
|
|
|
|
|
|
|
|
$timeout.cancel(promise);
|
|
|
|
|
$timeout.flush();
|
|
|
|
|
|
|
|
|
|
expect(log).toEqual(['promise error: canceled']);
|
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
2012-05-22 23:05:26 -07:00
|
|
|
it('should return true if a task was successfully canceled', inject(function($timeout) {
|
|
|
|
|
var task1 = jasmine.createSpy('task1'),
|
|
|
|
|
task2 = jasmine.createSpy('task2'),
|
|
|
|
|
promise1, promise2;
|
|
|
|
|
|
|
|
|
|
promise1 = $timeout(task1);
|
|
|
|
|
$timeout.flush();
|
|
|
|
|
promise2 = $timeout(task2);
|
|
|
|
|
|
|
|
|
|
expect($timeout.cancel(promise1)).toBe(false);
|
|
|
|
|
expect($timeout.cancel(promise2)).toBe(true);
|
|
|
|
|
}));
|
2012-06-01 14:50:01 -07:00
|
|
|
|
|
|
|
|
|
fix($timeout): throw when trying to cancel non-$timeout promise
Previously, calling `$timeout.cancel()` with a promise that was not
generated by a call to `$timeout()` would do nothing. This could, for
example, happen when calling `.then()`/`.catch()` on the returned
promise, which creates a new promise, and passing that to
`$timeout.cancel()`.
With this commit, `$timeout.cancel()` will throw an error if called with
a non-$timeout promise, thus surfacing errors that would otherwise go
unnoticed.
Fixes #16424
BREAKING CHNAGE:
`$timeout.cancel()` will throw an error if called with a promise that
was not generated by `$timeout()`. Previously, it would silently do
nothing.
Before:
```js
var promise = $timeout(doSomething, 1000).then(doSomethingElse);
$timeout.cancel(promise); // No error; timeout NOT canceled.
```
After:
```js
var promise = $timeout(doSomething, 1000).then(doSomethingElse);
$timeout.cancel(promise); // Throws error.
```
Correct usage:
```js
var promise = $timeout(doSomething, 1000);
var newPromise = promise.then(doSomethingElse);
$timeout.cancel(promise); // Timeout canceled.
```
2018-03-13 19:52:58 +02:00
|
|
|
it('should not throw an error when given an undefined promise', inject(function($timeout) {
|
2012-06-01 14:50:01 -07:00
|
|
|
expect($timeout.cancel()).toBe(false);
|
|
|
|
|
}));
|
2013-08-13 12:55:06 +01:00
|
|
|
|
|
|
|
|
|
fix($timeout): throw when trying to cancel non-$timeout promise
Previously, calling `$timeout.cancel()` with a promise that was not
generated by a call to `$timeout()` would do nothing. This could, for
example, happen when calling `.then()`/`.catch()` on the returned
promise, which creates a new promise, and passing that to
`$timeout.cancel()`.
With this commit, `$timeout.cancel()` will throw an error if called with
a non-$timeout promise, thus surfacing errors that would otherwise go
unnoticed.
Fixes #16424
BREAKING CHNAGE:
`$timeout.cancel()` will throw an error if called with a promise that
was not generated by `$timeout()`. Previously, it would silently do
nothing.
Before:
```js
var promise = $timeout(doSomething, 1000).then(doSomethingElse);
$timeout.cancel(promise); // No error; timeout NOT canceled.
```
After:
```js
var promise = $timeout(doSomething, 1000).then(doSomethingElse);
$timeout.cancel(promise); // Throws error.
```
Correct usage:
```js
var promise = $timeout(doSomething, 1000);
var newPromise = promise.then(doSomethingElse);
$timeout.cancel(promise); // Timeout canceled.
```
2018-03-13 19:52:58 +02:00
|
|
|
it('should throw an error when given a non-$timeout promise', inject(function($timeout) {
|
|
|
|
|
var promise = $timeout(noop).then(noop);
|
|
|
|
|
expect(function() { $timeout.cancel(promise); }).toThrowMinErr('$timeout', 'badprom');
|
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
|
2013-08-13 12:55:06 +01:00
|
|
|
it('should forget references to relevant deferred', inject(function($timeout, $browser) {
|
|
|
|
|
// $browser.defer.cancel is only called on cancel if the deferred object is still referenced
|
2016-03-13 13:20:30 +01:00
|
|
|
var cancelSpy = spyOn($browser.defer, 'cancel').and.callThrough();
|
2013-08-13 12:55:06 +01:00
|
|
|
|
2015-01-22 10:48:14 -08:00
|
|
|
var promise = $timeout(noop, 0, false);
|
2013-08-13 12:55:06 +01:00
|
|
|
|
|
|
|
|
expect(cancelSpy).not.toHaveBeenCalled();
|
|
|
|
|
$timeout.cancel(promise);
|
|
|
|
|
expect(cancelSpy).toHaveBeenCalledOnce();
|
|
|
|
|
|
|
|
|
|
// Promise deferred object should already be removed from the list and not cancellable again
|
|
|
|
|
$timeout.cancel(promise);
|
|
|
|
|
expect(cancelSpy).toHaveBeenCalledOnce();
|
|
|
|
|
}));
|
2017-07-03 02:04:17 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should not trigger digest when cancelled', inject(function($timeout, $rootScope, $browser) {
|
|
|
|
|
var watchSpy = jasmine.createSpy('watchSpy');
|
|
|
|
|
$rootScope.$watch(watchSpy);
|
|
|
|
|
|
|
|
|
|
var t = $timeout();
|
|
|
|
|
$timeout.cancel(t);
|
|
|
|
|
expect(function() {$browser.defer.flush();}).toThrowError('No deferred tasks to be flushed');
|
|
|
|
|
expect(watchSpy).not.toHaveBeenCalled();
|
|
|
|
|
}));
|
2012-05-22 23:05:26 -07:00
|
|
|
});
|
|
|
|
|
});
|
