Added a test of Dart_FunctionParameterCounts against a closure inside an

runtime/vm/dart_api_impl_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
@@ skipping 3698 matching lines @@
   // We can only invoke non-private imported functions.
   EXPECT_VALID(Dart_Invoke(lib1, Dart_NewString("imported"), 0, NULL));
   EXPECT_ERROR(Dart_Invoke(lib1, Dart_NewString("_imported"), 0, NULL),
                "did not find top-level function '_imported'");
 }
 
 TEST_CASE(ClosureFunction) {
   const char* kScriptChars =
       "Function getClosure() {\n"
       "  return (x, y, [z]) => x + y + z;\n"
+      "}\n"
+      "class Foo {\n"
+      "  getInstanceClosure() {\n"
+      "    return () { return this; };\n"
+      "  }\n"
+      "  getInstanceClosureWithArgs() {\n"
+      "    return (x, y, [z]) { return this; };\n"
+      "  }\n"
+      "  static getStaticClosure() {\n"
+      "    return () { return 42; };\n"
+      "  }\n"
+      "  static getStaticClosureWithArgs() {\n"
+      "    return (x, y, [z]) { return 42; };\n"
+      "  }\n"
+      "}\n"
+      "Function getInstanceClosure() {\n"
+      "  return new Foo().getInstanceClosure();\n"
+      "}\n"
+      "Function getInstanceClosureWithArgs() {\n"
+      "  return new Foo().getInstanceClosureWithArgs();\n"
+      "}\n"
+      "Function getStaticClosure() {\n"
+      "  return Foo.getStaticClosure();\n"
+      "}\n"
+      "Function getStaticClosureWithArgs() {\n"
+      "  return Foo.getStaticClosureWithArgs();\n"
       "}\n";
   Dart_Handle result;
   DARTSCOPE_NOCHECKS(Isolate::Current());
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke a function which returns a closure.
   Dart_Handle retobj = Dart_Invoke(lib, Dart_NewString("getClosure"), 0, NULL);
   EXPECT_VALID(retobj);
 
   EXPECT(Dart_IsClosure(retobj));
   EXPECT(!Dart_IsClosure(Dart_NewInteger(101)));
 
   // Retrieve the closure's function
   result = Dart_ClosureFunction(retobj);
   EXPECT_VALID(result);
   EXPECT(Dart_IsFunction(result));
-  int64_t fixed_param_count = -1;
-  int64_t opt_param_count = -1;
+  int64_t fixed_param_count = -999;
+  int64_t opt_param_count = -999;
   result = Dart_FunctionParameterCounts(result,
                                         &fixed_param_count,
                                         &opt_param_count);
   EXPECT_VALID(result);
   EXPECT_EQ(2, fixed_param_count);
   EXPECT_EQ(1, opt_param_count);
 
   // Try to retrieve function from a non-closure object
   result = Dart_ClosureFunction(Dart_NewInteger(1));
   EXPECT(Dart_IsError(result));
+
+  // Invoke a function which returns an "instance" closure.
+  retobj = Dart_Invoke(lib, Dart_NewString("getInstanceClosure"), 0, NULL);
+  EXPECT_VALID(retobj);
+  EXPECT(Dart_IsClosure(retobj));
+
+  // Retrieve the closure's function
+  result = Dart_ClosureFunction(retobj);
+  EXPECT_VALID(result);
+  EXPECT(Dart_IsFunction(result));
+  // -999: We want to distinguish between a non-answer and a wrong answer, and
+  // -1 has been a previous wrong answer
+  fixed_param_count = -999;
+  opt_param_count = -999;
+  result = Dart_FunctionParameterCounts(result,
+                                        &fixed_param_count,
+                                        &opt_param_count);
+  EXPECT_VALID(result);
+  EXPECT_EQ(0, fixed_param_count);
+  EXPECT_EQ(0, opt_param_count);
+
+  // Invoke a function which returns an "instance" closure with arguments.
+  retobj = Dart_Invoke(lib,
+                       Dart_NewString("getInstanceClosureWithArgs"),
+                       0,
+                       NULL);
+  EXPECT_VALID(retobj);
+  EXPECT(Dart_IsClosure(retobj));
+
+  // Retrieve the closure's function
+  result = Dart_ClosureFunction(retobj);
+  EXPECT_VALID(result);
+  EXPECT(Dart_IsFunction(result));
+  // -999: We want to distinguish between a non-answer and a wrong answer, and
+  // -1 has been a previous wrong answer
+  fixed_param_count = -999;
+  opt_param_count = -999;
+  result = Dart_FunctionParameterCounts(result,
+                                        &fixed_param_count,
+                                        &opt_param_count);
+  EXPECT_VALID(result);
+  EXPECT_EQ(2, fixed_param_count);
+  EXPECT_EQ(1, opt_param_count);
+
+  // Invoke a function which returns a "static" closure.
+  retobj = Dart_Invoke(lib, Dart_NewString("getStaticClosure"), 0, NULL);
+  EXPECT_VALID(retobj);
+  EXPECT(Dart_IsClosure(retobj));
+
+  // Retrieve the closure's function
+  result = Dart_ClosureFunction(retobj);
+  EXPECT_VALID(result);
+  EXPECT(Dart_IsFunction(result));
+  // -999: We want to distinguish between a non-answer and a wrong answer, and
+  // -1 has been a previous wrong answer
+  fixed_param_count = -999;
+  opt_param_count = -999;
+  result = Dart_FunctionParameterCounts(result,
+                                        &fixed_param_count,
+                                        &opt_param_count);
+  EXPECT_VALID(result);
+  EXPECT_EQ(0, fixed_param_count);
+  EXPECT_EQ(0, opt_param_count);
+
+
+  // Invoke a function which returns a "static" closure with arguments.
+  retobj = Dart_Invoke(lib,
+                       Dart_NewString("getStaticClosureWithArgs"),
+                       0,
+                       NULL);
+  EXPECT_VALID(retobj);
+  EXPECT(Dart_IsClosure(retobj));
+
+  // Retrieve the closure's function
+  result = Dart_ClosureFunction(retobj);
+  EXPECT_VALID(result);
+  EXPECT(Dart_IsFunction(result));
+  // -999: We want to distinguish between a non-answer and a wrong answer, and
+  // -1 has been a previous wrong answer
+  fixed_param_count = -999;
+  opt_param_count = -999;
+  result = Dart_FunctionParameterCounts(result,
+                                        &fixed_param_count,
+                                        &opt_param_count);
+  EXPECT_VALID(result);
+  EXPECT_EQ(2, fixed_param_count);
+  EXPECT_EQ(1, opt_param_count);
 }
 
 TEST_CASE(InvokeClosure) {
   const char* kScriptChars =
       "class InvokeClosure {\n"
       "  InvokeClosure(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  Function method1(int i) {\n"
       "    f(int j) => j + i + fld1 + fld2 + fld4; \n"
       "    return f;\n"
       "  }\n"
@@ skipping 2460 matching lines @@
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(0, value);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart