blob: bb930c8a459eea97ed495742640e3c9b6f72c984 [file] [log] [blame]
// Copyright 2011 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "v8.h"
#include "api.h"
#include "runtime.h"
#include "cctest.h"
using ::v8::internal::CStrVector;
using ::v8::internal::Factory;
using ::v8::internal::Handle;
using ::v8::internal::Heap;
using ::v8::internal::Isolate;
using ::v8::internal::JSFunction;
using ::v8::internal::Object;
using ::v8::internal::Runtime;
using ::v8::internal::Script;
using ::v8::internal::SmartPointer;
using ::v8::internal::SharedFunctionInfo;
using ::v8::internal::String;
static v8::Persistent<v8::Context> env;
static void InitializeVM() {
if (env.IsEmpty()) {
v8::HandleScope scope;
env = v8::Context::New();
}
v8::HandleScope scope;
env->Enter();
}
static void CheckFunctionName(v8::Handle<v8::Script> script,
const char* func_pos_src,
const char* ref_inferred_name) {
// Get script source.
Handle<Object> obj = v8::Utils::OpenHandle(*script);
Handle<SharedFunctionInfo> shared_function;
if (obj->IsSharedFunctionInfo()) {
shared_function =
Handle<SharedFunctionInfo>(SharedFunctionInfo::cast(*obj));
} else {
shared_function =
Handle<SharedFunctionInfo>(JSFunction::cast(*obj)->shared());
}
Handle<Script> i_script(Script::cast(shared_function->script()));
CHECK(i_script->source()->IsString());
Handle<String> script_src(String::cast(i_script->source()));
// Find the position of a given func source substring in the source.
Handle<String> func_pos_str =
FACTORY->NewStringFromAscii(CStrVector(func_pos_src));
int func_pos = Runtime::StringMatch(Isolate::Current(),
script_src,
func_pos_str,
0);
CHECK_NE(0, func_pos);
#ifdef ENABLE_DEBUGGER_SUPPORT
// Obtain SharedFunctionInfo for the function.
Object* shared_func_info_ptr =
Runtime::FindSharedFunctionInfoInScript(Isolate::Current(),
i_script,
func_pos);
CHECK(shared_func_info_ptr != HEAP->undefined_value());
Handle<SharedFunctionInfo> shared_func_info(
SharedFunctionInfo::cast(shared_func_info_ptr));
// Verify inferred function name.
SmartPointer<char> inferred_name =
shared_func_info->inferred_name()->ToCString();
CHECK_EQ(ref_inferred_name, *inferred_name);
#endif // ENABLE_DEBUGGER_SUPPORT
}
static v8::Handle<v8::Script> Compile(const char* src) {
return v8::Script::Compile(v8::String::New(src));
}
TEST(GlobalProperty) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"fun1 = function() { return 1; }\n"
"fun2 = function() { return 2; }\n");
CheckFunctionName(script, "return 1", "fun1");
CheckFunctionName(script, "return 2", "fun2");
}
TEST(GlobalVar) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"var fun1 = function() { return 1; }\n"
"var fun2 = function() { return 2; }\n");
CheckFunctionName(script, "return 1", "fun1");
CheckFunctionName(script, "return 2", "fun2");
}
TEST(LocalVar) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function outer() {\n"
" var fun1 = function() { return 1; }\n"
" var fun2 = function() { return 2; }\n"
"}");
CheckFunctionName(script, "return 1", "fun1");
CheckFunctionName(script, "return 2", "fun2");
}
TEST(InConstructor) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function MyClass() {\n"
" this.method1 = function() { return 1; }\n"
" this.method2 = function() { return 2; }\n"
"}");
CheckFunctionName(script, "return 1", "MyClass.method1");
CheckFunctionName(script, "return 2", "MyClass.method2");
}
TEST(Factory) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function createMyObj() {\n"
" var obj = {};\n"
" obj.method1 = function() { return 1; }\n"
" obj.method2 = function() { return 2; }\n"
" return obj;\n"
"}");
CheckFunctionName(script, "return 1", "obj.method1");
CheckFunctionName(script, "return 2", "obj.method2");
}
TEST(Static) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function MyClass() {}\n"
"MyClass.static1 = function() { return 1; }\n"
"MyClass.static2 = function() { return 2; }\n"
"MyClass.MyInnerClass = {}\n"
"MyClass.MyInnerClass.static3 = function() { return 3; }\n"
"MyClass.MyInnerClass.static4 = function() { return 4; }");
CheckFunctionName(script, "return 1", "MyClass.static1");
CheckFunctionName(script, "return 2", "MyClass.static2");
CheckFunctionName(script, "return 3", "MyClass.MyInnerClass.static3");
CheckFunctionName(script, "return 4", "MyClass.MyInnerClass.static4");
}
TEST(Prototype) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function MyClass() {}\n"
"MyClass.prototype.method1 = function() { return 1; }\n"
"MyClass.prototype.method2 = function() { return 2; }\n"
"MyClass.MyInnerClass = function() {}\n"
"MyClass.MyInnerClass.prototype.method3 = function() { return 3; }\n"
"MyClass.MyInnerClass.prototype.method4 = function() { return 4; }");
CheckFunctionName(script, "return 1", "MyClass.method1");
CheckFunctionName(script, "return 2", "MyClass.method2");
CheckFunctionName(script, "return 3", "MyClass.MyInnerClass.method3");
CheckFunctionName(script, "return 4", "MyClass.MyInnerClass.method4");
}
TEST(ObjectLiteral) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function MyClass() {}\n"
"MyClass.prototype = {\n"
" method1: function() { return 1; },\n"
" method2: function() { return 2; } }");
CheckFunctionName(script, "return 1", "MyClass.method1");
CheckFunctionName(script, "return 2", "MyClass.method2");
}
TEST(AsParameter) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function f1(a) { return a(); }\n"
"function f2(a, b) { return a() + b(); }\n"
"var result1 = f1(function() { return 1; })\n"
"var result2 = f2(function() { return 2; }, function() { return 3; })");
// Can't infer names here.
CheckFunctionName(script, "return 1", "");
CheckFunctionName(script, "return 2", "");
CheckFunctionName(script, "return 3", "");
}
TEST(MultipleFuncsConditional) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"fun1 = 0 ?\n"
" function() { return 1; } :\n"
" function() { return 2; }");
CheckFunctionName(script, "return 1", "fun1");
CheckFunctionName(script, "return 2", "fun1");
}
TEST(MultipleFuncsInLiteral) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function MyClass() {}\n"
"MyClass.prototype = {\n"
" method1: 0 ? function() { return 1; } :\n"
" function() { return 2; } }");
CheckFunctionName(script, "return 1", "MyClass.method1");
CheckFunctionName(script, "return 2", "MyClass.method1");
}
// See http://code.google.com/p/v8/issues/detail?id=380
TEST(Issue380) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function a() {\n"
"var result = function(p,a,c,k,e,d)"
"{return p}(\"if blah blah\",62,1976,\'a|b\'.split(\'|\'),0,{})\n"
"}");
CheckFunctionName(script, "return p", "");
}
TEST(MultipleAssignments) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"var fun1 = fun2 = function () { return 1; }\n"
"var bar1 = bar2 = bar3 = function () { return 2; }\n"
"foo1 = foo2 = function () { return 3; }\n"
"baz1 = baz2 = baz3 = function () { return 4; }");
CheckFunctionName(script, "return 1", "fun2");
CheckFunctionName(script, "return 2", "bar3");
CheckFunctionName(script, "return 3", "foo2");
CheckFunctionName(script, "return 4", "baz3");
}
TEST(AsConstructorParameter) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function Foo() {}\n"
"var foo = new Foo(function() { return 1; })\n"
"var bar = new Foo(function() { return 2; }, function() { return 3; })");
CheckFunctionName(script, "return 1", "");
CheckFunctionName(script, "return 2", "");
CheckFunctionName(script, "return 3", "");
}
TEST(FactoryHashmap) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function createMyObj() {\n"
" var obj = {};\n"
" obj[\"method1\"] = function() { return 1; }\n"
" obj[\"method2\"] = function() { return 2; }\n"
" return obj;\n"
"}");
CheckFunctionName(script, "return 1", "obj.method1");
CheckFunctionName(script, "return 2", "obj.method2");
}
TEST(FactoryHashmapVariable) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function createMyObj() {\n"
" var obj = {};\n"
" var methodName = \"method1\";\n"
" obj[methodName] = function() { return 1; }\n"
" methodName = \"method2\";\n"
" obj[methodName] = function() { return 2; }\n"
" return obj;\n"
"}");
// Can't infer function names statically.
CheckFunctionName(script, "return 1", "obj.(anonymous function)");
CheckFunctionName(script, "return 2", "obj.(anonymous function)");
}
TEST(FactoryHashmapConditional) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"function createMyObj() {\n"
" var obj = {};\n"
" obj[0 ? \"method1\" : \"method2\"] = function() { return 1; }\n"
" return obj;\n"
"}");
// Can't infer the function name statically.
CheckFunctionName(script, "return 1", "obj.(anonymous function)");
}
TEST(GlobalAssignmentAndCall) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"var Foo = function() {\n"
" return 1;\n"
"}();\n"
"var Baz = Bar = function() {\n"
" return 2;\n"
"}");
// The inferred name is empty, because this is an assignment of a result.
CheckFunctionName(script, "return 1", "");
// See MultipleAssignments test.
CheckFunctionName(script, "return 2", "Bar");
}
TEST(AssignmentAndCall) {
InitializeVM();
v8::HandleScope scope;
v8::Handle<v8::Script> script = Compile(
"(function Enclosing() {\n"
" var Foo;\n"
" Foo = function() {\n"
" return 1;\n"
" }();\n"
" var Baz = Bar = function() {\n"
" return 2;\n"
" }\n"
"})();");
// The inferred name is empty, because this is an assignment of a result.
CheckFunctionName(script, "return 1", "");
// See MultipleAssignments test.
CheckFunctionName(script, "return 2", "Enclosing.Bar");
}