Made it possible to distinguish between a method or top-level function and the

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 3727 matching lines @@
       "  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;
   Dart_Handle owner;
+  Dart_Handle defining_function;
   DARTSCOPE_NOCHECKS(Isolate::Current());
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   EXPECT_VALID(lib);
   Dart_Handle cls = Dart_GetClass(lib, Dart_NewString("Foo"));
   EXPECT_VALID(cls);
 
   // 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));
-  owner = Dart_FunctionEnclosingClassOrLibrary(result);
+  owner = Dart_FunctionOwner(result);
   EXPECT_VALID(owner);
-  EXPECT(Dart_IdentityEquals(owner, lib));
+  defining_function = Dart_LookupFunction(lib, Dart_NewString("getClosure"));
+  EXPECT(Dart_IdentityEquals(owner, defining_function));
   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));
-  owner = Dart_FunctionEnclosingClassOrLibrary(result);
+  owner = Dart_FunctionOwner(result);
   EXPECT_VALID(owner);
-  EXPECT(Dart_IdentityEquals(owner, cls));
+  defining_function = Dart_LookupFunction(cls,
+                                          Dart_NewString("getInstanceClosure"));
+  EXPECT(Dart_IdentityEquals(owner, defining_function));
   // -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));
-  owner = Dart_FunctionEnclosingClassOrLibrary(result);
+  owner = Dart_FunctionOwner(result);
   EXPECT_VALID(owner);
-  EXPECT(Dart_IdentityEquals(owner, cls));
+  defining_function =
+      Dart_LookupFunction(cls, Dart_NewString("getInstanceClosureWithArgs"));
+  EXPECT(Dart_IdentityEquals(owner, defining_function));
   // -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));
-  owner = Dart_FunctionEnclosingClassOrLibrary(result);
+  owner = Dart_FunctionOwner(result);
   EXPECT_VALID(owner);
-  EXPECT(Dart_IdentityEquals(owner, cls));
+  defining_function = Dart_LookupFunction(cls,
+                                          Dart_NewString("getStaticClosure"));
+  EXPECT(Dart_IdentityEquals(owner, defining_function));
   // -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));
-  owner = Dart_FunctionEnclosingClassOrLibrary(result);
+  owner = Dart_FunctionOwner(result);
   EXPECT_VALID(owner);
-  EXPECT(Dart_IdentityEquals(owner, cls));
+  defining_function =
+      Dart_LookupFunction(cls, Dart_NewString("getStaticClosureWithArgs"));
+  EXPECT(Dart_IdentityEquals(owner, defining_function));
   // -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);
@@ skipping 306 matching lines @@
   Dart_Handle private_cls = Dart_GetClass(lib, Dart_NewString("_PrivateClass"));
   EXPECT_VALID(private_cls);
   TextBuffer buffer(128);
 
   // Lookup a top-level function.
   Dart_Handle func = Dart_LookupFunction(lib, Dart_NewString("a"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("a 0 0 static", buffer.buf());
-  EXPECT(Dart_IsLibrary(Dart_FunctionEnclosingClassOrLibrary(func)));
-  Dart_Handle owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  EXPECT(Dart_IsLibrary(Dart_FunctionOwner(func)));
+  Dart_Handle owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, lib));
 
   // Lookup a private top-level function.
   func = Dart_LookupFunction(lib, Dart_NewString("_b"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_b 0 0 static", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, lib));
 
   // Lookup a top-level getter.
   func = Dart_LookupFunction(lib, Dart_NewString("c"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("c 0 0 static getter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, lib));
 
   // Lookup a top-level setter.
   func = Dart_LookupFunction(lib, Dart_NewString("d="));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("d= 1 0 static setter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, lib));
 
   // Lookup a private top-level getter.
   func = Dart_LookupFunction(lib, Dart_NewString("_e"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_e 0 0 static getter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, lib));
 
   // Lookup a private top-level setter.
   func = Dart_LookupFunction(lib, Dart_NewString("_f="));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_f= 1 0 static setter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, lib));
 
   // Lookup an unnamed constructor
   func = Dart_LookupFunction(cls, Dart_NewString("MyClass"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("MyClass 0 0 constructor", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a named constructor
   func = Dart_LookupFunction(cls, Dart_NewString("MyClass.named"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("MyClass.named 0 0 constructor", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup an private unnamed constructor
   func = Dart_LookupFunction(private_cls, Dart_NewString("_PrivateClass"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_PrivateClass 0 0 constructor", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, private_cls));
 
   // Lookup a private named constructor
   func = Dart_LookupFunction(private_cls,
                              Dart_NewString("_PrivateClass.named"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_PrivateClass.named 0 0 constructor", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, private_cls));
 
   // Lookup a method.
   func = Dart_LookupFunction(cls, Dart_NewString("a"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("a 0 0", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a private method.
   func = Dart_LookupFunction(cls, Dart_NewString("_b"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_b 0 0", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a instance getter.
   func = Dart_LookupFunction(cls, Dart_NewString("c"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("c 0 0 getter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a instance setter.
   func = Dart_LookupFunction(cls, Dart_NewString("d="));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("d= 1 0 setter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a private instance getter.
   func = Dart_LookupFunction(cls, Dart_NewString("_e"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_e 0 0 getter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a private instance setter.
   func = Dart_LookupFunction(cls, Dart_NewString("_f="));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_f= 1 0 setter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a static method.
   func = Dart_LookupFunction(cls, Dart_NewString("g"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("g 0 0 static", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a private static method.
   func = Dart_LookupFunction(cls, Dart_NewString("_h"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_h 0 0 static", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a static getter.
   func = Dart_LookupFunction(cls, Dart_NewString("i"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("i 0 0 static getter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a static setter.
   func = Dart_LookupFunction(cls, Dart_NewString("j="));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("j= 1 0 static setter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a private static getter.
   func = Dart_LookupFunction(cls, Dart_NewString("_k"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_k 0 0 static getter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a private static setter.
   func = Dart_LookupFunction(cls, Dart_NewString("_l="));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_l= 1 0 static setter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup an abstract method.
   func = Dart_LookupFunction(cls, Dart_NewString("m"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("m 0 0 abstract", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a private abstract method.
   func = Dart_LookupFunction(cls, Dart_NewString("_n"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_n 0 0 abstract", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a abstract getter.
   func = Dart_LookupFunction(cls, Dart_NewString("o"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("o 0 0 abstract getter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a abstract setter.
   func = Dart_LookupFunction(cls, Dart_NewString("p="));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("p= 1 0 abstract setter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a private abstract getter.
   func = Dart_LookupFunction(cls, Dart_NewString("_q"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_q 0 0 abstract getter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a private abstract setter.
   func = Dart_LookupFunction(cls, Dart_NewString("_r="));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("_r= 1 0 abstract setter", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a method with fixed and optional parameters.
   func = Dart_LookupFunction(cls, Dart_NewString("s"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("s 1 2", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a method with only optional parameters.
   func = Dart_LookupFunction(cls, Dart_NewString("t"));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("t 0 3", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup an operator
   func = Dart_LookupFunction(cls, Dart_NewString("=="));
   EXPECT_VALID(func);
   EXPECT(Dart_IsFunction(func));
   BuildFunctionDescription(&buffer, func);
   EXPECT_STREQ("== 1 0", buffer.buf());
-  owner = Dart_FunctionEnclosingClassOrLibrary(func);
+  owner = Dart_FunctionOwner(func);
   EXPECT_VALID(owner);
   EXPECT(Dart_IdentityEquals(owner, cls));
 
   // Lookup a function that does not exist from a library.
   func = Dart_LookupFunction(lib, Dart_NewString("DoesNotExist"));
   EXPECT(Dart_IsNull(func));
 
   // Lookup a function that does not exist from a class.
   func = Dart_LookupFunction(cls, Dart_NewString("DoesNotExist"));
   EXPECT(Dart_IsNull(func));
@@ skipping 2023 matching lines @@
   EXPECT(Dart_IsString(str));
   len = -1;
   EXPECT_VALID(Dart_StringLength(str, &len));
   EXPECT_EQ(0, len);
 }
 
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart