1 // Copyright 2007-2009 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28 #include "v8.h"
29
30 #include "api.h"
31 #include "runtime.h"
32 #include "cctest.h"
33
34
35 using ::v8::internal::CStrVector;
36 using ::v8::internal::Factory;
37 using ::v8::internal::Handle;
38 using ::v8::internal::Heap;
39 using ::v8::internal::JSFunction;
40 using ::v8::internal::Object;
41 using ::v8::internal::Runtime;
42 using ::v8::internal::Script;
43 using ::v8::internal::SmartPointer;
44 using ::v8::internal::SharedFunctionInfo;
45 using ::v8::internal::String;
46
47
48 static v8::Persistent<v8::Context> env;
49
50
InitializeVM()51 static void InitializeVM() {
52 if (env.IsEmpty()) {
53 v8::HandleScope scope;
54 env = v8::Context::New();
55 }
56 v8::HandleScope scope;
57 env->Enter();
58 }
59
60
CheckFunctionName(v8::Handle<v8::Script> script,const char * func_pos_src,const char * ref_inferred_name)61 static void CheckFunctionName(v8::Handle<v8::Script> script,
62 const char* func_pos_src,
63 const char* ref_inferred_name) {
64 // Get script source.
65 Handle<JSFunction> fun = v8::Utils::OpenHandle(*script);
66 Handle<Script> i_script(Script::cast(fun->shared()->script()));
67 CHECK(i_script->source()->IsString());
68 Handle<String> script_src(String::cast(i_script->source()));
69
70 // Find the position of a given func source substring in the source.
71 Handle<String> func_pos_str =
72 Factory::NewStringFromAscii(CStrVector(func_pos_src));
73 int func_pos = Runtime::StringMatch(script_src, func_pos_str, 0);
74 CHECK_NE(0, func_pos);
75
76 // Obtain SharedFunctionInfo for the function.
77 Object* shared_func_info_ptr =
78 Runtime::FindSharedFunctionInfoInScript(i_script, func_pos);
79 CHECK(shared_func_info_ptr != Heap::undefined_value());
80 Handle<SharedFunctionInfo> shared_func_info(
81 SharedFunctionInfo::cast(shared_func_info_ptr));
82
83 // Verify inferred function name.
84 SmartPointer<char> inferred_name =
85 shared_func_info->inferred_name()->ToCString();
86 CHECK_EQ(ref_inferred_name, *inferred_name);
87 }
88
89
Compile(const char * src)90 static v8::Handle<v8::Script> Compile(const char* src) {
91 return v8::Script::Compile(v8::String::New(src));
92 }
93
94
TEST(GlobalProperty)95 TEST(GlobalProperty) {
96 InitializeVM();
97 v8::HandleScope scope;
98
99 v8::Handle<v8::Script> script = Compile(
100 "fun1 = function() { return 1; }\n"
101 "fun2 = function() { return 2; }\n");
102 CheckFunctionName(script, "return 1", "fun1");
103 CheckFunctionName(script, "return 2", "fun2");
104 }
105
106
TEST(GlobalVar)107 TEST(GlobalVar) {
108 InitializeVM();
109 v8::HandleScope scope;
110
111 v8::Handle<v8::Script> script = Compile(
112 "var fun1 = function() { return 1; }\n"
113 "var fun2 = function() { return 2; }\n");
114 CheckFunctionName(script, "return 1", "fun1");
115 CheckFunctionName(script, "return 2", "fun2");
116 }
117
118
TEST(LocalVar)119 TEST(LocalVar) {
120 InitializeVM();
121 v8::HandleScope scope;
122
123 v8::Handle<v8::Script> script = Compile(
124 "function outer() {\n"
125 " var fun1 = function() { return 1; }\n"
126 " var fun2 = function() { return 2; }\n"
127 "}");
128 CheckFunctionName(script, "return 1", "fun1");
129 CheckFunctionName(script, "return 2", "fun2");
130 }
131
132
TEST(InConstructor)133 TEST(InConstructor) {
134 InitializeVM();
135 v8::HandleScope scope;
136
137 v8::Handle<v8::Script> script = Compile(
138 "function MyClass() {\n"
139 " this.method1 = function() { return 1; }\n"
140 " this.method2 = function() { return 2; }\n"
141 "}");
142 CheckFunctionName(script, "return 1", "MyClass.method1");
143 CheckFunctionName(script, "return 2", "MyClass.method2");
144 }
145
146
TEST(Factory)147 TEST(Factory) {
148 InitializeVM();
149 v8::HandleScope scope;
150
151 v8::Handle<v8::Script> script = Compile(
152 "function createMyObj() {\n"
153 " var obj = {};\n"
154 " obj.method1 = function() { return 1; }\n"
155 " obj.method2 = function() { return 2; }\n"
156 " return obj;\n"
157 "}");
158 CheckFunctionName(script, "return 1", "obj.method1");
159 CheckFunctionName(script, "return 2", "obj.method2");
160 }
161
162
TEST(Static)163 TEST(Static) {
164 InitializeVM();
165 v8::HandleScope scope;
166
167 v8::Handle<v8::Script> script = Compile(
168 "function MyClass() {}\n"
169 "MyClass.static1 = function() { return 1; }\n"
170 "MyClass.static2 = function() { return 2; }\n"
171 "MyClass.MyInnerClass = {}\n"
172 "MyClass.MyInnerClass.static3 = function() { return 3; }\n"
173 "MyClass.MyInnerClass.static4 = function() { return 4; }");
174 CheckFunctionName(script, "return 1", "MyClass.static1");
175 CheckFunctionName(script, "return 2", "MyClass.static2");
176 CheckFunctionName(script, "return 3", "MyClass.MyInnerClass.static3");
177 CheckFunctionName(script, "return 4", "MyClass.MyInnerClass.static4");
178 }
179
180
TEST(Prototype)181 TEST(Prototype) {
182 InitializeVM();
183 v8::HandleScope scope;
184
185 v8::Handle<v8::Script> script = Compile(
186 "function MyClass() {}\n"
187 "MyClass.prototype.method1 = function() { return 1; }\n"
188 "MyClass.prototype.method2 = function() { return 2; }\n"
189 "MyClass.MyInnerClass = function() {}\n"
190 "MyClass.MyInnerClass.prototype.method3 = function() { return 3; }\n"
191 "MyClass.MyInnerClass.prototype.method4 = function() { return 4; }");
192 CheckFunctionName(script, "return 1", "MyClass.method1");
193 CheckFunctionName(script, "return 2", "MyClass.method2");
194 CheckFunctionName(script, "return 3", "MyClass.MyInnerClass.method3");
195 CheckFunctionName(script, "return 4", "MyClass.MyInnerClass.method4");
196 }
197
198
TEST(ObjectLiteral)199 TEST(ObjectLiteral) {
200 InitializeVM();
201 v8::HandleScope scope;
202
203 v8::Handle<v8::Script> script = Compile(
204 "function MyClass() {}\n"
205 "MyClass.prototype = {\n"
206 " method1: function() { return 1; },\n"
207 " method2: function() { return 2; } }");
208 CheckFunctionName(script, "return 1", "MyClass.method1");
209 CheckFunctionName(script, "return 2", "MyClass.method2");
210 }
211
212
TEST(AsParameter)213 TEST(AsParameter) {
214 InitializeVM();
215 v8::HandleScope scope;
216
217 v8::Handle<v8::Script> script = Compile(
218 "function f1(a) { return a(); }\n"
219 "function f2(a, b) { return a() + b(); }\n"
220 "var result1 = f1(function() { return 1; })\n"
221 "var result2 = f2(function() { return 2; }, function() { return 3; })");
222 // Can't infer names here.
223 CheckFunctionName(script, "return 1", "");
224 CheckFunctionName(script, "return 2", "");
225 CheckFunctionName(script, "return 3", "");
226 }
227
228
TEST(MultipleFuncsConditional)229 TEST(MultipleFuncsConditional) {
230 InitializeVM();
231 v8::HandleScope scope;
232
233 v8::Handle<v8::Script> script = Compile(
234 "fun1 = 0 ?\n"
235 " function() { return 1; } :\n"
236 " function() { return 2; }");
237 CheckFunctionName(script, "return 1", "fun1");
238 CheckFunctionName(script, "return 2", "fun1");
239 }
240
241
TEST(MultipleFuncsInLiteral)242 TEST(MultipleFuncsInLiteral) {
243 InitializeVM();
244 v8::HandleScope scope;
245
246 v8::Handle<v8::Script> script = Compile(
247 "function MyClass() {}\n"
248 "MyClass.prototype = {\n"
249 " method1: 0 ? function() { return 1; } :\n"
250 " function() { return 2; } }");
251 CheckFunctionName(script, "return 1", "MyClass.method1");
252 CheckFunctionName(script, "return 2", "MyClass.method1");
253 }
254
255
256 // See http://code.google.com/p/v8/issues/detail?id=380
TEST(Issue380)257 TEST(Issue380) {
258 InitializeVM();
259 v8::HandleScope scope;
260
261 v8::Handle<v8::Script> script = Compile(
262 "function a() {\n"
263 "var result = function(p,a,c,k,e,d)"
264 "{return p}(\"if blah blah\",62,1976,\'a|b\'.split(\'|\'),0,{})\n"
265 "}");
266 CheckFunctionName(script, "return p", "");
267 }
268