Finishing API error processing, and cleanup

chrome/browser/resources/google_now/utility_unittest.gtestjs

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * Test fixture for utility.js.
  * @constructor
  * @extends {testing.Test}
  */
 function GoogleNowUtilityUnitTest () {
@@ skipping 453 matching lines @@
 
 TEST_F('GoogleNowUtilityUnitTest', 'TaskManager2Sequential', function() {
   // Tests that 2 tasks get successfully executed consecutively, even if the
   // second one conflicts with the first.
   
   // Setup.
   var test = setUpTaskManagerTest(this);
 
   // Step 1. Add 1st task that doesn't create pending callbacks.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task1(ANYTHING);
+  this.mockLocalFunctions.expects(once()).task1();
   // Invocation.
   test.tasks.add(taskNameA, this.mockLocalFunctions.functions().task1);
   Mock4JS.verifyAllMocks();
 
   // Step 2. Add 2nd task.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task2(ANYTHING);
+  this.mockLocalFunctions.expects(once()).task2();
   // Invocation.
   test.tasks.add(taskNameB, this.mockLocalFunctions.functions().task2);
 });
 
 TEST_F('GoogleNowUtilityUnitTest', 'TaskManagerConflicting', function() {
   // Tests that adding a task while a conflicting task is being executed causes
   // the second one to be ignored.
 
   // Setup.
   var test = setUpTaskManagerTest(this);
   var task1PluginInstance;
 
   // Step 1. Add 1st task that creates a pending callback.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task1(ANYTHING).
+  this.mockLocalFunctions.expects(once()).task1().
       will(callFunction(function() {
         task1PluginInstance = test.pluginFactory();
       }));
   // Invocation.
   test.tasks.add(taskNameA, this.mockLocalFunctions.functions().task1);
   Mock4JS.verifyAllMocks();
 
   // Step 2. Add 2nd task. Since it conflicts with currently running task1
   // (see areTasksConflicting), it should be ignored.
   test.tasks.add(taskNameB, this.mockLocalFunctions.functions().task2);
@@ skipping 10 matching lines @@
 TEST_F('GoogleNowUtilityUnitTest', 'TaskManagerNestedTaskEnqueue', function() {
   // Tests that adding a task while a non-conflicting task is being executed
   // causes the second one to be executed after the first one completes.
 
   // Setup.
   var test = setUpTaskManagerTest(this);
   var task1PluginInstance;
 
   // Step 1. Add 1st task that creates a pending callback.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task1(ANYTHING).
+  this.mockLocalFunctions.expects(once()).task1().
       will(callFunction(function() {
         task1PluginInstance = test.pluginFactory();
       }));
   // Invocation.
   test.tasks.add(taskNameA, this.mockLocalFunctions.functions().task1);
   Mock4JS.verifyAllMocks();
 
   // Step 2. Add 2nd task. Since it doesn't conflict with currently running
   // task1 (see areTasksConflicting), it should not be ignored.
   test.tasks.add(taskNameC, this.mockLocalFunctions.functions().task2);
   Mock4JS.verifyAllMocks();
 
   // Step 3. Enter the callback of task1.
   task1PluginInstance.prologue();
   Mock4JS.verifyAllMocks();
 
   // Step 4. Leave the callback of task1.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task2(ANYTHING);
+  this.mockLocalFunctions.expects(once()).task2();
   // Invocation.
   task1PluginInstance.epilogue();
 });
 
 TEST_F('GoogleNowUtilityUnitTest', 'TaskManagerBranching', function() {
   // Tests that task manager correctly detects completion of tasks that create
   // branching chains of callbacks (in this test, task1 creates pending
   // callbacks 1 and 2, and callback 1 creates pending callback 3).
 
   // Setup.
   var test = setUpTaskManagerTest(this);
   var task1PluginInstance1, task1PluginInstance2, task1PluginInstance3;
 
   // Step 1. Add 1st task that creates a 2 pending callbacks.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task1(ANYTHING).
+  this.mockLocalFunctions.expects(once()).task1().
       will(callFunction(function() {
         task1PluginInstance1 = test.pluginFactory();
         task1PluginInstance2 = test.pluginFactory();
       }));
   // Invocation.
   test.tasks.add(taskNameA, this.mockLocalFunctions.functions().task1);
   Mock4JS.verifyAllMocks();
 
   // Step 2. Add 2nd task, which is not conflicting (see areTasksConflicting)
   // with task1.
   test.tasks.add(taskNameC, this.mockLocalFunctions.functions().task2);
   Mock4JS.verifyAllMocks();
 
   // Step 3. Enter callback 1, create pending callback 3, exit callback 1.
   // Enter/exit callback 2. Enter callback 3.
   task1PluginInstance1.prologue();
   task1PluginInstance3 = test.pluginFactory();
   task1PluginInstance1.epilogue();
   task1PluginInstance2.prologue();
   task1PluginInstance2.epilogue();
   task1PluginInstance3.prologue();
   Mock4JS.verifyAllMocks();
 
   // Step 4. Leave 3rd callback of task1. Now task1 is complete, and task2
   // should start.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task2(ANYTHING);
+  this.mockLocalFunctions.expects(once()).task2();
   // Invocation.
   task1PluginInstance3.epilogue();
 });
 
 TEST_F('GoogleNowUtilityUnitTest', 'TaskManagerSuspendError', function() {
   // Tests that task manager's onSuspend method reports an error if there are
   // pending tasks.
 
   // Setup.
   var test = setUpTaskManagerTest(this);
   var onSuspendHandlerContainer = getMockHandlerContainer('runtime.onSuspend');
 
   // Step 1. Add a task that creates a pending callback.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task1(ANYTHING).
+  this.mockLocalFunctions.expects(once()).task1().
       will(callFunction(function() {
         test.pluginFactory();
       }));
   // Invocation.
   test.tasks.add(taskNameA, this.mockLocalFunctions.functions().task1);
   Mock4JS.verifyAllMocks();
 
   // Step 2. Invoke onSuspend event of the task manager.
   // Setup and expectations. The 2 callbacks in onSuspendHandlerContainer are
   // from the wrapper and the task manager.
   assertEquals(2, onSuspendHandlerContainer.length);
   this.mockGlobals.expects(once()).reportError(eqToString(
       'Error: ASSERT: Incomplete task when unloading event page,' +
       ' queue = [{"name":"TASK A"}], testWrapperDebugState'));
   // Invocation.
   onSuspendHandlerContainer[1]();
 });
 
 TEST_F('GoogleNowUtilityUnitTest', 'TaskManagerSuspendSuccess', function() {
   // Tests that task manager's onSuspend method does not report an error if all
   // tasks completed.
 
   // Setup.
   var test = setUpTaskManagerTest(this);
   var onSuspendHandlerContainer = getMockHandlerContainer('runtime.onSuspend');
   var task1PluginInstance;
 
   // Step 1. Add a task that creates a pending callback.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task1(ANYTHING).
+  this.mockLocalFunctions.expects(once()).task1().
       will(callFunction(function() {
         task1PluginInstance = test.pluginFactory();
       }));
   // Invocation.
   test.tasks.add(taskNameA, this.mockLocalFunctions.functions().task1);
   Mock4JS.verifyAllMocks();
 
   // Step 2. Invoke task's callback and the onSuspend event of the task manager.
   // The 2 callbacks in onSuspendHandlerContainer are from the wrapper and the
   // task manager.
   task1PluginInstance.prologue();
   task1PluginInstance.epilogue();
   onSuspendHandlerContainer[1]();
 });
 
 TEST_F('GoogleNowUtilityUnitTest', 'TaskManager3Tasks', function() {
   // Tests that 3 tasks can be executed too. In particular, that if the second 
   // task is a single-step task which execution was originally blocked by task1,
   // unblocking it causes immediate synchronous execution of both tasks 2 and 3.
 
   // Setup.
   var test = setUpTaskManagerTest(this);
   var task1PluginInstance;
 
   // Step 1. Add 1st task that creates a pending callback.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task1(ANYTHING).
+  this.mockLocalFunctions.expects(once()).task1().
       will(callFunction(function() {
         task1PluginInstance = test.pluginFactory();
       }));
   // Invocation.
   test.tasks.add(taskNameA, this.mockLocalFunctions.functions().task1);
   Mock4JS.verifyAllMocks();
 
   // Step 2. Add 2nd and 3rd tasks, both non-conflicting (see
   // areTasksConflicting) with task1.
   test.tasks.add(taskNameC, this.mockLocalFunctions.functions().task2);
   test.tasks.add(taskNameC, this.mockLocalFunctions.functions().task3);
   Mock4JS.verifyAllMocks();
 
   // Step 3. Enter the callback of task1.
   task1PluginInstance.prologue();
   Mock4JS.verifyAllMocks();
 
   // Step 4. Leave the callback of task1.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task2(ANYTHING);
-  this.mockLocalFunctions.expects(once()).task3(ANYTHING);
+  this.mockLocalFunctions.expects(once()).task2();
+  this.mockLocalFunctions.expects(once()).task3();
   // Invocation.
   task1PluginInstance.epilogue();
 });
 
 TEST_F('GoogleNowUtilityUnitTest', 'TaskManagerNestedNonTask', function() {
   // Tests callbacks requested while a task is running, but not from a callback
   // belonging to a task, are not counted as a part of the task.
 
   // Setup.
   var test = setUpTaskManagerTest(this);
   var task1PluginInstance;
 
   // Step 1. Add 1st task that creates a pending callback.
   // Expectations.
-  this.mockLocalFunctions.expects(once()).task1(ANYTHING).
+  this.mockLocalFunctions.expects(once()).task1().
       will(callFunction(function() {
         task1PluginInstance = test.pluginFactory();
       }));
   // Invocation.
   test.tasks.add(taskNameA, this.mockLocalFunctions.functions().task1);
   Mock4JS.verifyAllMocks();
 
   // Step 2. Create a pending callback from code that is not a part of the task.
   test.pluginFactory();
   Mock4JS.verifyAllMocks();
 
   // Step 3. Enter the callback of task1. After this, task1 should be
   // finished despite the pending non-task callback.
   task1PluginInstance.prologue();
   task1PluginInstance.epilogue();
   Mock4JS.verifyAllMocks();
 
   // Step 4. Check that task1 is finished by submitting task2, which should
   // be executed immediately.
-  this.mockLocalFunctions.expects(once()).task2(ANYTHING);
+  this.mockLocalFunctions.expects(once()).task2();
   test.tasks.add(taskNameC, this.mockLocalFunctions.functions().task2);
 });
 
 var testAttemptAlarmName = 'attempt-scheduler-testAttempts';
 var testAttemptStorageKey = 'current-delay-testAttempts';
 var testInitialDelaySeconds = 239;
 var testMaximumDelaySeconds = 2239;
 // Value to be returned by mocked Math.random(). We want the value returned by
 // Math.random() to be predictable to be able to check results against expected
 // values. A fixed seed would be okay, but fixed seeding isn't possible in JS at
@@ skipping 202 matching lines @@
   var alarmsGetSavedArgs = new SaveMockArguments();
   this.mockApis.expects(once()).
       instrumented_alarms_get(
           alarmsGetSavedArgs.match(eq(testAttemptAlarmName)),
           alarmsGetSavedArgs.match(ANYTHING)).
       will(invokeCallback(alarmsGetSavedArgs, 1, {testField: 'TEST VALUE'}));
   this.mockLocalFunctions.expects(once()).attempt();
   // Invocation.
   onAlarmHandlerContainer[0]({name: testAttemptAlarmName});
 });