struct ParserTest : public testing::Test {
void AssertParse(const char* input) {
- ManifestParser parser(&state, &fs_, kDupeEdgeActionWarn);
+ ManifestParser parser(&state, &fs_);
string err;
EXPECT_TRUE(parser.ParseTest(input, &err));
ASSERT_EQ("", err);
"build out1 out2: cat in1\n"
"build out1: cat in2\n"
"build final: cat out1\n";
- ManifestParser parser(&state, &fs_, kDupeEdgeActionError);
+ ManifestParserOptions parser_opts;
+ parser_opts.dupe_edge_action_ = kDupeEdgeActionError;
+ ManifestParser parser(&state, &fs_, parser_opts);
string err;
EXPECT_FALSE(parser.ParseTest(kInput, &err));
EXPECT_EQ("input:5: multiple rules generate out1 [-w dupbuild=err]\n", err);
"build final: cat out1\n");
const char kInput[] =
"subninja sub.ninja\n";
- ManifestParser parser(&state, &fs_, kDupeEdgeActionError);
+ ManifestParserOptions parser_opts;
+ parser_opts.dupe_edge_action_ = kDupeEdgeActionError;
+ ManifestParser parser(&state, &fs_, parser_opts);
string err;
EXPECT_FALSE(parser.ParseTest(kInput, &err));
EXPECT_EQ("sub.ninja:5: multiple rules generate out1 [-w dupbuild=err]\n",
err);
}
+TEST_F(ParserTest, PhonySelfReferenceIgnored) {
+ ASSERT_NO_FATAL_FAILURE(AssertParse(
+"build a: phony a\n"
+));
+
+ Node* node = state.LookupNode("a");
+ Edge* edge = node->in_edge();
+ ASSERT_TRUE(edge->inputs_.empty());
+}
+
+TEST_F(ParserTest, PhonySelfReferenceKept) {
+ const char kInput[] =
+"build a: phony a\n";
+ ManifestParserOptions parser_opts;
+ parser_opts.phony_cycle_action_ = kPhonyCycleActionError;
+ ManifestParser parser(&state, &fs_, parser_opts);
+ string err;
+ EXPECT_TRUE(parser.ParseTest(kInput, &err));
+ EXPECT_EQ("", err);
+
+ Node* node = state.LookupNode("a");
+ Edge* edge = node->in_edge();
+ ASSERT_EQ(edge->inputs_.size(), 1);
+ ASSERT_EQ(edge->inputs_[0], node);
+}
+
TEST_F(ParserTest, ReservedWords) {
ASSERT_NO_FATAL_FAILURE(AssertParse(
"rule build\n"
TEST_F(ParserTest, Errors) {
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest(string("subn", 4), &err));
EXPECT_EQ("input:1: expected '=', got eof\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("foobar", &err));
EXPECT_EQ("input:1: expected '=', got eof\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("x 3", &err));
EXPECT_EQ("input:1: expected '=', got identifier\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("x = 3", &err));
EXPECT_EQ("input:1: unexpected EOF\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("x = 3\ny 2", &err));
EXPECT_EQ("input:2: expected '=', got identifier\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("x = $", &err));
EXPECT_EQ("input:1: bad $-escape (literal $ must be written as $$)\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("x = $\n $[\n", &err));
EXPECT_EQ("input:2: bad $-escape (literal $ must be written as $$)\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("x = a$\n b$\n $\n", &err));
EXPECT_EQ("input:4: unexpected EOF\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("build\n", &err));
EXPECT_EQ("input:1: expected path\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("build x: y z\n", &err));
EXPECT_EQ("input:1: unknown build rule 'y'\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("build x:: y z\n", &err));
EXPECT_EQ("input:1: expected build command name\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cat\n command = cat ok\n"
"build x: cat $\n :\n",
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cat\n",
&err));
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cat\n"
" command = echo\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cat\n"
" command = echo\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cat\n"
" command = ${fafsd\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cat\n"
" command = cat\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cat\n"
" command = cat\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule %foo\n",
&err));
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cc\n"
" command = foo\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cc\n command = foo\n"
"build $.: cc bar.cc\n",
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cc\n command = foo\n && bar",
&err));
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cc\n command = foo\n"
"build $: cc bar.cc\n",
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("default\n",
&err));
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("default nonexistent\n",
&err));
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule r\n command = r\n"
"build b: r\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("default $a\n", &err));
EXPECT_EQ("input:1: empty path\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule r\n"
" command = r\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
// the indented blank line must terminate the rule
// this also verifies that "unexpected (token)" errors are correct
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("pool\n", &err));
EXPECT_EQ("input:1: expected pool name\n", err);
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("pool foo\n", &err));
EXPECT_EQ("input:2: expected 'depth =' line\n", err);
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("pool foo\n"
" depth = 4\n"
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("pool foo\n"
" depth = -1\n", &err));
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("pool foo\n"
" bar = 1\n", &err));
{
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
// Pool names are dereferenced at edge parsing time.
EXPECT_FALSE(parser.ParseTest("rule run\n"
TEST_F(ParserTest, MissingInput) {
State local_state;
- ManifestParser parser(&local_state, &fs_, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, &fs_);
string err;
EXPECT_FALSE(parser.Load("build.ninja", &err));
EXPECT_EQ("loading 'build.ninja': No such file or directory", err);
TEST_F(ParserTest, MultipleOutputs) {
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_TRUE(parser.ParseTest("rule cc\n command = foo\n depfile = bar\n"
"build a.o b.o: cc c.cc\n",
TEST_F(ParserTest, MultipleOutputsWithDeps) {
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_FALSE(parser.ParseTest("rule cc\n command = foo\n deps = gcc\n"
"build a.o b.o: cc c.cc\n",
}
TEST_F(ParserTest, MissingSubNinja) {
- ManifestParser parser(&state, &fs_, kDupeEdgeActionWarn);
+ ManifestParser parser(&state, &fs_);
string err;
EXPECT_FALSE(parser.ParseTest("subninja foo.ninja\n", &err));
EXPECT_EQ("input:1: loading 'foo.ninja': No such file or directory\n"
// Test that rules are scoped to subninjas.
fs_.Create("test.ninja", "rule cat\n"
" command = cat\n");
- ManifestParser parser(&state, &fs_, kDupeEdgeActionWarn);
+ ManifestParser parser(&state, &fs_);
string err;
EXPECT_TRUE(parser.ParseTest("rule cat\n"
" command = cat\n"
" command = cat\n");
fs_.Create("test.ninja", "include rules.ninja\n"
"build x : cat\n");
- ManifestParser parser(&state, &fs_, kDupeEdgeActionWarn);
+ ManifestParser parser(&state, &fs_);
string err;
EXPECT_TRUE(parser.ParseTest("include rules.ninja\n"
"subninja test.ninja\n"
TEST_F(ParserTest, BrokenInclude) {
fs_.Create("include.ninja", "build\n");
- ManifestParser parser(&state, &fs_, kDupeEdgeActionWarn);
+ ManifestParser parser(&state, &fs_);
string err;
EXPECT_FALSE(parser.ParseTest("include include.ninja\n", &err));
EXPECT_EQ("include.ninja:1: expected path\n"
}
TEST_F(ParserTest, NoExplicitOutput) {
- ManifestParser parser(&state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&state, NULL);
string err;
EXPECT_TRUE(parser.ParseTest(
"rule cat\n"
TEST_F(ParserTest, CRLF) {
State local_state;
- ManifestParser parser(&local_state, NULL, kDupeEdgeActionWarn);
+ ManifestParser parser(&local_state, NULL);
string err;
EXPECT_TRUE(parser.ParseTest("# comment with crlf\r\n", &err));