Add more tests for compiler-dispatcher

test/unittests/compiler-dispatcher/compiler-dispatcher-unittest.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler-dispatcher/compiler-dispatcher.h"
 
 #include "include/v8-platform.h"
 #include "src/base/platform/semaphore.h"
 #include "src/compiler-dispatcher/compiler-dispatcher-job.h"
 #include "src/compiler-dispatcher/compiler-dispatcher-tracer.h"
@@ skipping 288 matching lines @@
   }
   script += " 'x'; }; return f5; } g();";
   Handle<JSFunction> f =
       Handle<JSFunction>::cast(RunJS(isolate(), script.c_str()));
   Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
 
   ASSERT_FALSE(platform.IdleTaskPending());
   ASSERT_TRUE(dispatcher.Enqueue(shared));
   ASSERT_TRUE(platform.IdleTaskPending());
 
-  // Idle tasks shouldn't leave exceptions behind.
-  v8::TryCatch try_catch(isolate());
-
   // Since time doesn't progress on the MockPlatform, this is enough idle time
   // to finish compiling the function.
   platform.RunIdleTask(1000.0, 0.0);
 
   ASSERT_FALSE(dispatcher.IsEnqueued(shared));
   ASSERT_FALSE(shared->is_compiled());
-  ASSERT_FALSE(try_catch.HasCaught());
+  ASSERT_FALSE(i_isolate()->has_pending_exception());
 }
 
 TEST_F(IgnitionCompilerDispatcherTest, CompileOnBackgroundThread) {
   MockPlatform platform;
   CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
 
   const char script[] =
       "function g() { var y = 1; function f6(x) { return x * y }; return f6; } "
       "g();";
   Handle<JSFunction> f = Handle<JSFunction>::cast(RunJS(isolate(), script));
@@ skipping 68 matching lines @@
   platform.RunBackgroundTasks(V8::GetCurrentPlatform());
 
   ASSERT_TRUE(dispatcher.FinishNow(shared));
   // Finishing removes the SFI from the queue.
   ASSERT_FALSE(dispatcher.IsEnqueued(shared));
   ASSERT_TRUE(shared->is_compiled());
   if (platform.IdleTaskPending()) platform.ClearIdleTask();
   ASSERT_FALSE(platform.BackgroundTasksPending());
 }
 
+TEST_F(CompilerDispatcherTest, IdleTaskMultipleJobs) {
+  MockPlatform platform;
+  CompilerDispatcher dispatcher(i_isolate(), &platform, FLAG_stack_size);
+
+  const char script1[] =
+      "function g() { var y = 1; function f8(x) { return x * y }; return f8; } "
+      "g();";
+  Handle<JSFunction> f1 = Handle<JSFunction>::cast(RunJS(isolate(), script1));
+  Handle<SharedFunctionInfo> shared1(f1->shared(), i_isolate());
+
+  const char script2[] =
+      "function g() { var y = 1; function f9(x) { return x * y }; return f9; } "
+      "g();";
+  Handle<JSFunction> f2 = Handle<JSFunction>::cast(RunJS(isolate(), script2));
+  Handle<SharedFunctionInfo> shared2(f2->shared(), i_isolate());
+
+  ASSERT_FALSE(platform.IdleTaskPending());
+  ASSERT_TRUE(dispatcher.Enqueue(shared1));
+  ASSERT_TRUE(dispatcher.Enqueue(shared2));
+  ASSERT_TRUE(platform.IdleTaskPending());
+
+  // Since time doesn't progress on the MockPlatform, this is enough idle time
+  // to finish compiling the function.
+  platform.RunIdleTask(1000.0, 0.0);
+
+  ASSERT_FALSE(dispatcher.IsEnqueued(shared1));
+  ASSERT_FALSE(dispatcher.IsEnqueued(shared2));
+  ASSERT_TRUE(shared1->is_compiled());
+  ASSERT_TRUE(shared2->is_compiled());
+}
+
+TEST_F(CompilerDispatcherTest, FinishNowException) {
+  MockPlatform platform;
+  CompilerDispatcher dispatcher(i_isolate(), &platform, 50);

[vogelheim, 2017/01/04 10:08:49]

For my understanding: The point is to over-run an artificially small stack?

[jochen (gone - plz use gerrit), 2017/01/04 10:23:18]

yes

we can't put a real syntax error here, because RunJS() wouldn't work then

+
+  std::string script("function g() { function f10(x) { var a = ");
+  for (int i = 0; i < 1000; i++) {
+    script += "'x' + ";
+  }
+  script += " 'x'; }; return f10; } g();";
+  Handle<JSFunction> f =
+      Handle<JSFunction>::cast(RunJS(isolate(), script.c_str()));
+  Handle<SharedFunctionInfo> shared(f->shared(), i_isolate());
+
+  ASSERT_FALSE(platform.IdleTaskPending());
+  ASSERT_TRUE(dispatcher.Enqueue(shared));
+  ASSERT_TRUE(platform.IdleTaskPending());
+
+  ASSERT_FALSE(dispatcher.FinishNow(shared));
+
+  ASSERT_FALSE(dispatcher.IsEnqueued(shared));
+  ASSERT_FALSE(shared->is_compiled());
+  ASSERT_TRUE(i_isolate()->has_pending_exception());
+
+  i_isolate()->clear_pending_exception();
+  platform.ClearIdleTask();
+}
+
 }  // namespace internal
 }  // namespace v8