action_state_composition.hpp のバグ修正とテスト強化

diff --git a/src/parser/action_state_composition.hpp b/src/parser/action_state_composition.hpp
index 08e1191..d304521 100644 (file)
--- a/src/parser/action_state_composition.hpp
+++ b/src/parser/action_state_composition.hpp
@@ -56,6 +56,17 @@ public:
     }
 };
 
+template<>
+class CompositionAction<Grammar::Identifier>
+{
+public:
+    template<typename... TCommonStates>
+    static void apply(const pegtl::input& in, CompositionState& st, TCommonStates&...)
+    {
+        st.ASTNode.Name = in.string();
+    }
+};
+
 class TrackListBlockState
 {
 public:
@@ -102,7 +113,7 @@ class TrackBlockAction : public pegtl::nothing<TRule>
 };
 
 template<>
-class TrackBlockAction<Grammar::TrackListBlock>
+class TrackBlockAction<Grammar::TrackBlock>
 {
 public:
     template<typename... TCommonStates>

diff --git a/test/parser/parsertest.cpp b/test/parser/parsertest.cpp
index 667601f..b0c6964 100644 (file)
--- a/test/parser/parsertest.cpp
+++ b/test/parser/parsertest.cpp
@@ -6,6 +6,7 @@
 #include <ast/module.hpp>
 #include <parser/parser.hpp>
 
+using namespace YAMML;
 using namespace YAMML::Parser;
 
 BOOST_AUTO_TEST_SUITE(ParserTest)
@@ -35,11 +36,92 @@ composition Main
     YAMMLParser parser("test.ym1", source);
 
     bool result = parser.Parse();
-    BOOST_CHECK(result);
+    BOOST_REQUIRE(result);
 
     auto module = parser.GetAST();
 
-    BOOST_CHECK(module->Phrases.find("Foo") != module->Phrases.end());
+    {
+        auto itPhrase = module->Phrases.find("Foo");
+
+        BOOST_REQUIRE(itPhrase != module->Phrases.end());
+
+        BOOST_CHECK_EQUAL(itPhrase->first, "Foo");
+
+        auto phrase = itPhrase->second;
+
+        BOOST_CHECK_EQUAL(phrase.Name, "Foo");
+        BOOST_CHECK(phrase.Attributes.empty());
+        BOOST_CHECK_EQUAL(phrase.Location.Line, 3);
+        BOOST_CHECK_EQUAL(phrase.Location.Column, 0);
+
+        BOOST_CHECK_EQUAL(phrase.Block.Location.Line, 4);
+        BOOST_CHECK_EQUAL(phrase.Block.Location.Column, 0);
+
+        {
+            auto noteSeqStatement = boost::get<YAMML::AST::NoteSequenceStatement>(phrase.Block.Sequences.at(0));
+            BOOST_CHECK(noteSeqStatement.Attributes.empty());
+
+            BOOST_REQUIRE(noteSeqStatement.NoteSeq.is_initialized());
+            auto noteSeq = *noteSeqStatement.NoteSeq;
+
+            BOOST_CHECK_EQUAL(noteSeq.Notes.size(), 1);
+
+            auto noteAndExpr = noteSeq.Notes.at(0);
+            BOOST_CHECK_EQUAL(noteAndExpr.Notes.size(), 3);
+
+            {
+                auto noteAndDuration = boost::get<AST::NoteAndDuration>(noteAndExpr.Notes.at(0));
+                BOOST_CHECK(!noteAndDuration.Duration.is_initialized());
+                BOOST_CHECK_EQUAL(boost::get<AST::NoteNumber>(noteAndDuration.Note).Name.Name, 'C');
+                BOOST_CHECK(!boost::get<AST::NoteNumber>(noteAndDuration.Note).Octave.is_initialized());
+            }
+
+            {
+                auto noteAndDuration = boost::get<AST::NoteAndDuration>(noteAndExpr.Notes.at(1));
+                BOOST_CHECK(!noteAndDuration.Duration.is_initialized());
+                BOOST_CHECK_EQUAL(boost::get<AST::NoteNumber>(noteAndDuration.Note).Name.Name, 'E');
+                BOOST_CHECK(!boost::get<AST::NoteNumber>(noteAndDuration.Note).Octave.is_initialized());
+            }
+
+            {
+                auto noteAndDuration = boost::get<AST::NoteAndDuration>(noteAndExpr.Notes.at(2));
+                BOOST_CHECK(!noteAndDuration.Duration.is_initialized());
+                BOOST_CHECK_EQUAL(boost::get<AST::NoteNumber>(noteAndDuration.Note).Name.Name, 'G');
+                BOOST_CHECK(!boost::get<AST::NoteNumber>(noteAndDuration.Note).Octave.is_initialized());
+            }
+        }
+    }
+
+    {
+        auto itComposition = module->Compositions.find("Main");
+        BOOST_REQUIRE(itComposition != module->Compositions.end());
+
+        BOOST_CHECK_EQUAL(itComposition->first, "Main");
+
+        auto composition = itComposition->second;
+
+        BOOST_CHECK_EQUAL(composition.Name, "Main");
+        BOOST_CHECK(composition.Attributes.empty());
+        BOOST_CHECK_EQUAL(composition.Location.Line, 8);
+        BOOST_CHECK_EQUAL(composition.Location.Column, 0);
+
+        BOOST_CHECK_EQUAL(composition.Statements.size(), 1);
+
+        auto trackListBlock = boost::get<AST::TrackListBlock>(composition.Statements.at(0));
+        BOOST_CHECK_EQUAL(trackListBlock.Tracks.size(), 1);
+
+        auto trackBlock = trackListBlock.Tracks.at(0);
+        BOOST_CHECK_EQUAL(trackBlock.TrackNumber, 1);
+        BOOST_CHECK(trackBlock.Attributes.empty());
+        BOOST_CHECK_EQUAL(trackBlock.Location.Line, 12);
+        BOOST_CHECK_EQUAL(trackBlock.Location.Column, 8);
+        BOOST_CHECK_EQUAL(trackBlock.Items.size(), 1);
+
+        auto trackItem = trackBlock.Items.at(0);
+
+        BOOST_CHECK_EQUAL(trackItem.PhraseName, "Foo");
+        BOOST_CHECK(trackItem.Attributes.empty());
+    }
 }
 
 BOOST_AUTO_TEST_CASE(ParserTest2)