tools/gn/parse_tree_unittest.cc

   1 // Copyright 2014 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/test_with_scope.h"
  10
  11 TEST(ParseTree, Accessor) {
  12   TestWithScope setup;
  13
  14   // Make a pretend parse node with proper tracking that we can blame for the
  15   // given value.
  16   InputFile input_file(SourceFile("//foo"));
  17   Token base_token(Location(&input_file, 1, 1, 1), Token::IDENTIFIER, "a");
  18   Token member_token(Location(&input_file, 1, 1, 1), Token::IDENTIFIER, "b");
  19
  20   AccessorNode accessor;
  21   accessor.set_base(base_token);
  22
  23   scoped_ptr<IdentifierNode> member_identifier(
  24       new IdentifierNode(member_token));
  25   accessor.set_member(member_identifier.Pass());
  26
  27   // The access should fail because a is not defined.
  28   Err err;
  29   Value result = accessor.Execute(setup.scope(), &err);
  30   EXPECT_TRUE(err.has_error());
  31   EXPECT_EQ(Value::NONE, result.type());
  32
  33   // Define a as a Scope. It should still fail because b isn't defined.
  34   err = Err();
  35   setup.scope()->SetValue(
  36       "a", Value(nullptr, scoped_ptr<Scope>(new Scope(setup.scope()))),
  37       nullptr);
  38   result = accessor.Execute(setup.scope(), &err);
  39   EXPECT_TRUE(err.has_error());
  40   EXPECT_EQ(Value::NONE, result.type());
  41
  42   // Define b, accessor should succeed now.
  43   const int64 kBValue = 42;
  44   err = Err();
  45   setup.scope()
  46       ->GetMutableValue("a", false)
  47       ->scope_value()
  48       ->SetValue("b", Value(nullptr, kBValue), nullptr);
  49   result = accessor.Execute(setup.scope(), &err);
  50   EXPECT_FALSE(err.has_error());
  51   ASSERT_EQ(Value::INTEGER, result.type());
  52   EXPECT_EQ(kBValue, result.int_value());
  53 }
  54
  55 TEST(ParseTree, BlockUnusedVars) {
  56   TestWithScope setup;
  57
  58   // Printing both values should be OK.
  59   TestParseInput input_all_used(
  60       "{\n"
  61       "  a = 12\n"
  62       "  b = 13\n"
  63       "  print(\"$a $b\")\n"
  64       "}");
  65   EXPECT_FALSE(input_all_used.has_error());
  66
  67   Err err;
  68   input_all_used.parsed()->Execute(setup.scope(), &err);
  69   EXPECT_FALSE(err.has_error());
  70
  71   // Skipping one should throw an unused var error.
  72   TestParseInput input_unused(
  73       "{\n"
  74       "  a = 12\n"
  75       "  b = 13\n"
  76       "  print(\"$a\")\n"
  77       "}");
  78   EXPECT_FALSE(input_unused.has_error());
  79
  80   input_unused.parsed()->Execute(setup.scope(), &err);
  81   EXPECT_TRUE(err.has_error());
  82
  83   // Also verify that the unused variable has the correct origin set. The
  84   // origin will point to the value assigned to the variable (in this case, the
  85   // "13" assigned to "b".
  86   EXPECT_EQ(3, err.location().line_number());
  87   EXPECT_EQ(7, err.location().char_offset());
  88
  89 }
  90
  91 TEST(ParseTree, OriginForDereference) {
  92   TestWithScope setup;
  93   TestParseInput input(
  94       "a = 6\n"
  95       "get_target_outputs(a)");
  96   EXPECT_FALSE(input.has_error());
  97
  98   Err err;
  99   input.parsed()->Execute(setup.scope(), &err);
 100   EXPECT_TRUE(err.has_error());
 101
 102   // The origin for the "not a string" error message should be where the value
 103   // was dereferenced (the "a" on the second line).
 104   EXPECT_EQ(2, err.location().line_number());
 105   EXPECT_EQ(20, err.location().char_offset());
 106 }
 107
 108 TEST(ParseTree, SortRangeExtraction) {
 109   TestWithScope setup;
 110
 111   // Ranges are [begin, end).
 112
 113   {
 114     TestParseInput input(
 115         "sources = [\n"
 116         "  \"a\",\n"
 117         "  \"b\",\n"
 118         "  \n"
 119         "  #\n"
 120         "  # Block\n"
 121         "  #\n"
 122         "  \n"
 123         "  \"c\","
 124         "  \"d\","
 125         "]\n");
 126     EXPECT_FALSE(input.has_error());
 127     ASSERT_TRUE(input.parsed()->AsBlock());
 128     ASSERT_TRUE(input.parsed()->AsBlock()->statements()[0]->AsBinaryOp());
 129     const BinaryOpNode* binop =
 130         input.parsed()->AsBlock()->statements()[0]->AsBinaryOp();
 131     ASSERT_TRUE(binop->right()->AsList());
 132     const ListNode* list = binop->right()->AsList();
 133     EXPECT_EQ(5u, list->contents().size());
 134     auto ranges = list->GetSortRanges();
 135     ASSERT_EQ(2u, ranges.size());
 136     EXPECT_EQ(0u, ranges[0].begin);
 137     EXPECT_EQ(2u, ranges[0].end);
 138     EXPECT_EQ(3u, ranges[1].begin);
 139     EXPECT_EQ(5u, ranges[1].end);
 140   }
 141
 142   {
 143     TestParseInput input(
 144         "sources = [\n"
 145         "  \"a\",\n"
 146         "  \"b\",\n"
 147         "  \n"
 148         "  # Attached comment.\n"
 149         "  \"c\","
 150         "  \"d\","
 151         "]\n");
 152     EXPECT_FALSE(input.has_error());
 153     ASSERT_TRUE(input.parsed()->AsBlock());
 154     ASSERT_TRUE(input.parsed()->AsBlock()->statements()[0]->AsBinaryOp());
 155     const BinaryOpNode* binop =
 156         input.parsed()->AsBlock()->statements()[0]->AsBinaryOp();
 157     ASSERT_TRUE(binop->right()->AsList());
 158     const ListNode* list = binop->right()->AsList();
 159     EXPECT_EQ(4u, list->contents().size());
 160     auto ranges = list->GetSortRanges();
 161     ASSERT_EQ(2u, ranges.size());
 162     EXPECT_EQ(0u, ranges[0].begin);
 163     EXPECT_EQ(2u, ranges[0].end);
 164     EXPECT_EQ(2u, ranges[1].begin);
 165     EXPECT_EQ(4u, ranges[1].end);
 166   }
 167
 168   {
 169     TestParseInput input(
 170         "sources = [\n"
 171         "  # At end of list.\n"
 172         "  \"zzzzzzzzzzz.cc\","
 173         "]\n");
 174     EXPECT_FALSE(input.has_error());
 175     ASSERT_TRUE(input.parsed()->AsBlock());
 176     ASSERT_TRUE(input.parsed()->AsBlock()->statements()[0]->AsBinaryOp());
 177     const BinaryOpNode* binop =
 178         input.parsed()->AsBlock()->statements()[0]->AsBinaryOp();
 179     ASSERT_TRUE(binop->right()->AsList());
 180     const ListNode* list = binop->right()->AsList();
 181     EXPECT_EQ(1u, list->contents().size());
 182     auto ranges = list->GetSortRanges();
 183     ASSERT_EQ(1u, ranges.size());
 184     EXPECT_EQ(0u, ranges[0].begin);
 185     EXPECT_EQ(1u, ranges[0].end);
 186   }
 187
 188   {
 189     TestParseInput input(
 190         "sources = [\n"
 191         "  # Block at start.\n"
 192         "  \n"
 193         "  \"z.cc\","
 194         "  \"y.cc\","
 195         "]\n");
 196     EXPECT_FALSE(input.has_error());
 197     ASSERT_TRUE(input.parsed()->AsBlock());
 198     ASSERT_TRUE(input.parsed()->AsBlock()->statements()[0]->AsBinaryOp());
 199     const BinaryOpNode* binop =
 200         input.parsed()->AsBlock()->statements()[0]->AsBinaryOp();
 201     ASSERT_TRUE(binop->right()->AsList());
 202     const ListNode* list = binop->right()->AsList();
 203     EXPECT_EQ(3u, list->contents().size());
 204     auto ranges = list->GetSortRanges();
 205     ASSERT_EQ(1u, ranges.size());
 206     EXPECT_EQ(1u, ranges[0].begin);
 207     EXPECT_EQ(3u, ranges[0].end);
 208   }
 209 }