1// Copyright (c) 2013 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "testing/gtest/include/gtest/gtest.h" 6#include "tools/gn/input_file.h" 7#include "tools/gn/parse_tree.h" 8#include "tools/gn/scope.h" 9#include "tools/gn/template.h" 10#include "tools/gn/test_with_scope.h" 11 12namespace { 13 14bool HasStringValueEqualTo(const Scope* scope, 15 const char* name, 16 const char* expected_value) { 17 const Value* value = scope->GetValue(name); 18 if (!value) 19 return false; 20 if (value->type() != Value::STRING) 21 return false; 22 return value->string_value() == expected_value; 23} 24 25} // namespace 26 27TEST(Scope, NonRecursiveMergeTo) { 28 TestWithScope setup; 29 30 // Make a pretend parse node with proper tracking that we can blame for the 31 // given value. 32 InputFile input_file(SourceFile("//foo")); 33 Token assignment_token(Location(&input_file, 1, 1, 1), Token::STRING, 34 "\"hello\""); 35 LiteralNode assignment; 36 assignment.set_value(assignment_token); 37 38 // Add some values to the scope. 39 Value old_value(&assignment, "hello"); 40 setup.scope()->SetValue("v", old_value, &assignment); 41 base::StringPiece private_var_name("_private"); 42 setup.scope()->SetValue(private_var_name, old_value, &assignment); 43 44 // Add some templates to the scope. 45 FunctionCallNode templ_definition; 46 scoped_refptr<Template> templ(new Template(setup.scope(), &templ_definition)); 47 setup.scope()->AddTemplate("templ", templ.get()); 48 scoped_refptr<Template> private_templ( 49 new Template(setup.scope(), &templ_definition)); 50 setup.scope()->AddTemplate("_templ", private_templ.get()); 51 52 // Detect collisions of values' values. 53 { 54 Scope new_scope(setup.settings()); 55 Value new_value(&assignment, "goodbye"); 56 new_scope.SetValue("v", new_value, &assignment); 57 58 Err err; 59 EXPECT_FALSE(setup.scope()->NonRecursiveMergeTo( 60 &new_scope, Scope::MergeOptions(), 61 &assignment, "error", &err)); 62 EXPECT_TRUE(err.has_error()); 63 } 64 65 // Template name collisions. 66 { 67 Scope new_scope(setup.settings()); 68 69 scoped_refptr<Template> new_templ( 70 new Template(&new_scope, &templ_definition)); 71 new_scope.AddTemplate("templ", new_templ.get()); 72 73 Err err; 74 EXPECT_FALSE(setup.scope()->NonRecursiveMergeTo( 75 &new_scope, Scope::MergeOptions(), &assignment, "error", &err)); 76 EXPECT_TRUE(err.has_error()); 77 } 78 79 // The clobber flag should just overwrite colliding values. 80 { 81 Scope new_scope(setup.settings()); 82 Value new_value(&assignment, "goodbye"); 83 new_scope.SetValue("v", new_value, &assignment); 84 85 Err err; 86 Scope::MergeOptions options; 87 options.clobber_existing = true; 88 EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo( 89 &new_scope, options, &assignment, "error", &err)); 90 EXPECT_FALSE(err.has_error()); 91 92 const Value* found_value = new_scope.GetValue("v"); 93 ASSERT_TRUE(found_value); 94 EXPECT_TRUE(old_value == *found_value); 95 } 96 97 // Clobber flag for templates. 98 { 99 Scope new_scope(setup.settings()); 100 101 scoped_refptr<Template> new_templ( 102 new Template(&new_scope, &templ_definition)); 103 new_scope.AddTemplate("templ", new_templ.get()); 104 Scope::MergeOptions options; 105 options.clobber_existing = true; 106 107 Err err; 108 EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo( 109 &new_scope, options, &assignment, "error", &err)); 110 EXPECT_FALSE(err.has_error()); 111 112 const Template* found_value = new_scope.GetTemplate("templ"); 113 ASSERT_TRUE(found_value); 114 EXPECT_TRUE(templ.get() == found_value); 115 } 116 117 // Don't flag values that technically collide but have the same value. 118 { 119 Scope new_scope(setup.settings()); 120 Value new_value(&assignment, "hello"); 121 new_scope.SetValue("v", new_value, &assignment); 122 123 Err err; 124 EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo( 125 &new_scope, Scope::MergeOptions(), &assignment, "error", &err)); 126 EXPECT_FALSE(err.has_error()); 127 } 128 129 // Templates that technically collide but are the same. 130 { 131 Scope new_scope(setup.settings()); 132 133 scoped_refptr<Template> new_templ( 134 new Template(&new_scope, &templ_definition)); 135 new_scope.AddTemplate("templ", templ.get()); 136 137 Err err; 138 EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo( 139 &new_scope, Scope::MergeOptions(), &assignment, "error", &err)); 140 EXPECT_FALSE(err.has_error()); 141 } 142 143 // Copy private values and templates. 144 { 145 Scope new_scope(setup.settings()); 146 147 Err err; 148 EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo( 149 &new_scope, Scope::MergeOptions(), &assignment, "error", &err)); 150 EXPECT_FALSE(err.has_error()); 151 EXPECT_TRUE(new_scope.GetValue(private_var_name)); 152 EXPECT_TRUE(new_scope.GetTemplate("_templ")); 153 } 154 155 // Skip private values and templates. 156 { 157 Scope new_scope(setup.settings()); 158 159 Err err; 160 Scope::MergeOptions options; 161 options.skip_private_vars = true; 162 EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo( 163 &new_scope, options, &assignment, "error", &err)); 164 EXPECT_FALSE(err.has_error()); 165 EXPECT_FALSE(new_scope.GetValue(private_var_name)); 166 EXPECT_FALSE(new_scope.GetTemplate("_templ")); 167 } 168 169 // Don't mark used. 170 { 171 Scope new_scope(setup.settings()); 172 173 Err err; 174 Scope::MergeOptions options; 175 EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo( 176 &new_scope, options, &assignment, "error", &err)); 177 EXPECT_FALSE(err.has_error()); 178 EXPECT_FALSE(new_scope.CheckForUnusedVars(&err)); 179 EXPECT_TRUE(err.has_error()); 180 } 181 182 // Mark used. 183 { 184 Scope new_scope(setup.settings()); 185 186 Err err; 187 Scope::MergeOptions options; 188 options.mark_used = true; 189 EXPECT_TRUE(setup.scope()->NonRecursiveMergeTo( 190 &new_scope, options, &assignment, "error", &err)); 191 EXPECT_FALSE(err.has_error()); 192 EXPECT_TRUE(new_scope.CheckForUnusedVars(&err)); 193 EXPECT_FALSE(err.has_error()); 194 } 195} 196 197TEST(Scope, MakeClosure) { 198 // Create 3 nested scopes [const root from setup] <- nested1 <- nested2. 199 TestWithScope setup; 200 201 // Make a pretend parse node with proper tracking that we can blame for the 202 // given value. 203 InputFile input_file(SourceFile("//foo")); 204 Token assignment_token(Location(&input_file, 1, 1, 1), Token::STRING, 205 "\"hello\""); 206 LiteralNode assignment; 207 assignment.set_value(assignment_token); 208 setup.scope()->SetValue("on_root", Value(&assignment, "on_root"), 209 &assignment); 210 211 // Root scope should be const from the nested caller's perspective. 212 Scope nested1(static_cast<const Scope*>(setup.scope())); 213 nested1.SetValue("on_one", Value(&assignment, "on_one"), &assignment); 214 215 Scope nested2(&nested1); 216 nested2.SetValue("on_one", Value(&assignment, "on_two"), &assignment); 217 nested2.SetValue("on_two", Value(&assignment, "on_two2"), &assignment); 218 219 // Making a closure from the root scope. 220 scoped_ptr<Scope> result = setup.scope()->MakeClosure(); 221 EXPECT_FALSE(result->containing()); // Should have no containing scope. 222 EXPECT_TRUE(result->GetValue("on_root")); // Value should be copied. 223 224 // Making a closure from the second nested scope. 225 result = nested2.MakeClosure(); 226 EXPECT_EQ(setup.scope(), 227 result->containing()); // Containing scope should be the root. 228 EXPECT_TRUE(HasStringValueEqualTo(result.get(), "on_root", "on_root")); 229 EXPECT_TRUE(HasStringValueEqualTo(result.get(), "on_one", "on_two")); 230 EXPECT_TRUE(HasStringValueEqualTo(result.get(), "on_two", "on_two2")); 231} 232 233TEST(Scope, GetMutableValue) { 234 TestWithScope setup; 235 236 // Make a pretend parse node with proper tracking that we can blame for the 237 // given value. 238 InputFile input_file(SourceFile("//foo")); 239 Token assignment_token(Location(&input_file, 1, 1, 1), Token::STRING, 240 "\"hello\""); 241 LiteralNode assignment; 242 assignment.set_value(assignment_token); 243 244 const char kOnConst[] = "on_const"; 245 const char kOnMutable1[] = "on_mutable1"; 246 const char kOnMutable2[] = "on_mutable2"; 247 248 Value value(&assignment, "hello"); 249 250 // Create a root scope with one value. 251 Scope root_scope(setup.settings()); 252 root_scope.SetValue(kOnConst, value, &assignment); 253 254 // Create a first nested scope with a different value. 255 const Scope* const_root_scope = &root_scope; 256 Scope mutable_scope1(const_root_scope); 257 mutable_scope1.SetValue(kOnMutable1, value, &assignment); 258 259 // Create a second nested scope with a different value. 260 Scope mutable_scope2(&mutable_scope1); 261 mutable_scope2.SetValue(kOnMutable2, value, &assignment); 262 263 // Check getting root scope values. 264 EXPECT_TRUE(mutable_scope2.GetValue(kOnConst, true)); 265 EXPECT_FALSE(mutable_scope2.GetMutableValue(kOnConst, true)); 266 267 // Test reading a value from scope 1. 268 Value* mutable1_result = mutable_scope2.GetMutableValue(kOnMutable1, false); 269 ASSERT_TRUE(mutable1_result); 270 EXPECT_TRUE(*mutable1_result == value); 271 272 // Make sure CheckForUnusedVars works on scope1 (we didn't mark the value as 273 // used in the previous step). 274 Err err; 275 EXPECT_FALSE(mutable_scope1.CheckForUnusedVars(&err)); 276 mutable1_result = mutable_scope2.GetMutableValue(kOnMutable1, true); 277 EXPECT_TRUE(mutable1_result); 278 err = Err(); 279 EXPECT_TRUE(mutable_scope1.CheckForUnusedVars(&err)); 280 281 // Test reading a value from scope 2. 282 Value* mutable2_result = mutable_scope2.GetMutableValue(kOnMutable2, true); 283 ASSERT_TRUE(mutable2_result); 284 EXPECT_TRUE(*mutable2_result == value); 285} 286 287TEST(Scope, RemovePrivateIdentifiers) { 288 TestWithScope setup; 289 setup.scope()->SetValue("a", Value(NULL, true), NULL); 290 setup.scope()->SetValue("_b", Value(NULL, true), NULL); 291 292 setup.scope()->RemovePrivateIdentifiers(); 293 EXPECT_TRUE(setup.scope()->GetValue("a")); 294 EXPECT_FALSE(setup.scope()->GetValue("_b")); 295} 296