| // Copyright (c) 2016 The WebM project authors. All Rights Reserved. | |
| // | |
| // Use of this source code is governed by a BSD-style license | |
| // that can be found in the LICENSE file in the root of the source | |
| // tree. An additional intellectual property rights grant can be found | |
| // in the file PATENTS. All contributing project authors may | |
| // be found in the AUTHORS file in the root of the source tree. | |
| #include "src/master_parser.h" | |
| #include <cstdint> | |
| #include <memory> | |
| #include <vector> | |
| #include "gmock/gmock.h" | |
| #include "gtest/gtest.h" | |
| #include "src/byte_parser.h" | |
| #include "test_utils/element_parser_test.h" | |
| #include "webm/element.h" | |
| #include "webm/id.h" | |
| #include "webm/status.h" | |
| using testing::_; | |
| using testing::DoAll; | |
| using testing::InSequence; | |
| using testing::NotNull; | |
| using testing::Return; | |
| using testing::SetArgPointee; | |
| using webm::Action; | |
| using webm::BinaryParser; | |
| using webm::ElementMetadata; | |
| using webm::ElementParser; | |
| using webm::ElementParserTest; | |
| using webm::Id; | |
| using webm::kUnknownElementSize; | |
| using webm::LimitedReader; | |
| using webm::MasterParser; | |
| using webm::Status; | |
| namespace { | |
| // Simple helper method that just takes an Id and ElementParser* and returns | |
| // them in a std::pair<Id, std::unique_ptr<ElementParser>>. Provided just for | |
| // simplifying some statements. | |
| std::pair<Id, std::unique_ptr<ElementParser>> ParserForId( | |
| Id id, ElementParser* parser) { | |
| return {id, std::unique_ptr<ElementParser>(parser)}; | |
| } | |
| class MasterParserTest : public ElementParserTest<MasterParser> {}; | |
| // Errors parsing an ID should be returned to the caller. | |
| TEST_F(MasterParserTest, BadId) { | |
| SetReaderData({ | |
| 0x00, // Invalid ID. | |
| 0x80, // ID = 0x80 (unknown). | |
| 0x80, // Size = 0. | |
| }); | |
| EXPECT_CALL(callback_, OnElementBegin(_, _)).Times(0); | |
| ParseAndExpectResult(Status::kInvalidElementId); | |
| } | |
| // Errors from a child parser's Init should be returned to the caller. | |
| TEST_F(MasterParserTest, ChildInitFails) { | |
| SetReaderData({ | |
| 0xEC, // ID = 0xEC (Void). | |
| 0xFF, // Size = unknown. | |
| }); | |
| const ElementMetadata metadata = {Id::kVoid, 2, kUnknownElementSize, 0}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| ParseAndExpectResult(Status::kInvalidElementSize); | |
| } | |
| // Indefinite unknown children should result in an error. | |
| TEST_F(MasterParserTest, IndefiniteUnknownChild) { | |
| SetReaderData({ | |
| 0x80, // ID = 0x80 (unknown). | |
| 0xFF, // Size = unknown. | |
| 0x00, 0x00, // Body. | |
| }); | |
| EXPECT_CALL(callback_, OnElementBegin(_, _)).Times(0); | |
| ParseAndExpectResult(Status::kIndefiniteUnknownElement); | |
| } | |
| // Child elements that overflow the master element's size should be detected. | |
| TEST_F(MasterParserTest, ChildOverflow) { | |
| SetReaderData({ | |
| 0xEC, // ID = 0xEC (Void). | |
| 0x82, // Size = 2. | |
| 0x00, 0x00, // Body. | |
| }); | |
| EXPECT_CALL(callback_, OnElementBegin(_, _)).Times(0); | |
| EXPECT_CALL(callback_, OnVoid(_, _, _)).Times(0); | |
| ParseAndExpectResult(Status::kElementOverflow, reader_.size() - 1); | |
| } | |
| // Child elements with an unknown size can't be naively checked to see if they | |
| // overflow the master element's size. Make sure the overflow is still detected. | |
| TEST_F(MasterParserTest, ChildOverflowWithUnknownSize) { | |
| SetReaderData({ | |
| 0xA1, // ID = 0xA1 (Block) (master). | |
| 0xFF, // Size = unknown. | |
| 0xEC, // ID = 0xEC (Void) (child). | |
| 0x81, // Size = 1. | |
| 0x12, // Body. | |
| }); | |
| { | |
| InSequence dummy; | |
| ElementMetadata metadata = {Id::kBlock, 2, kUnknownElementSize, 0}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| } | |
| ResetParser(ParserForId(Id::kBlock, new MasterParser)); | |
| ParseAndExpectResult(Status::kElementOverflow, 4); | |
| } | |
| // An element with an unknown size should be terminated by its parents bounds. | |
| TEST_F(MasterParserTest, ChildWithUnknownSizeBoundedByParentSize) { | |
| SetReaderData({ | |
| 0xA1, // ID = 0xA1 (Block) (master). | |
| 0xFF, // Size = unknown. | |
| 0xEC, // ID = 0xEC (Void) (child). | |
| 0x81, // Size = 1. | |
| 0x12, // Body. | |
| 0x00, // Invalid ID. This should not be read. | |
| }); | |
| { | |
| InSequence dummy; | |
| ElementMetadata metadata = {Id::kBlock, 2, kUnknownElementSize, 0}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| metadata = {Id::kVoid, 2, 1, 2}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| EXPECT_CALL(callback_, OnVoid(metadata, NotNull(), NotNull())).Times(1); | |
| } | |
| ResetParser(ParserForId(Id::kBlock, new MasterParser)); | |
| ParseAndVerify(reader_.size() - 1); | |
| } | |
| // An empty master element is okay. | |
| TEST_F(MasterParserTest, Empty) { | |
| EXPECT_CALL(callback_, OnElementBegin(_, _)).Times(0); | |
| ParseAndVerify(); | |
| } | |
| // Unrecognized children should be skipped over. | |
| TEST_F(MasterParserTest, UnknownChildren) { | |
| SetReaderData({ | |
| 0x40, 0x00, // ID = 0x4000 (unknown). | |
| 0x80, // Size = 0. | |
| 0x80, // ID = 0x80 (unknown). | |
| 0x40, 0x00, // Size = 0. | |
| }); | |
| EXPECT_CALL(callback_, OnVoid(_, _, _)).Times(0); | |
| { | |
| InSequence dummy; | |
| ElementMetadata metadata = {static_cast<Id>(0x4000), 3, 0, 0}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| metadata = {static_cast<Id>(0x80), 3, 0, 3}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| } | |
| ParseAndVerify(); | |
| } | |
| // A master element with unknown size is terminated by the first element that is | |
| // not a valid child. | |
| TEST_F(MasterParserTest, UnknownSize) { | |
| SetReaderData({ | |
| // Void elements may appear anywhere in a master element and should not | |
| // terminate the parse for a master element with an unknown size. In other | |
| // words, they're always valid children. | |
| 0xEC, // ID = 0xEC (Void). | |
| 0x81, // Size = 1. | |
| 0x00, // Body. | |
| // This element marks the end for the parser since this is the first | |
| // unrecognized element. The ID and size should be read (which the parser | |
| // uses to determine the end has been reached), but nothing more. | |
| 0x80, // ID = 0x80 (unknown). | |
| 0x81, // Size = 1. | |
| 0x12, // Body. | |
| }); | |
| { | |
| InSequence dummy; | |
| const ElementMetadata metadata = {Id::kVoid, 2, 1, 0}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| EXPECT_CALL(callback_, OnVoid(metadata, NotNull(), NotNull())).Times(1); | |
| } | |
| ParseAndVerify(kUnknownElementSize); | |
| EXPECT_EQ(static_cast<std::uint64_t>(5), reader_.Position()); | |
| } | |
| // Consecutive elements with unknown size should parse without issues, despite | |
| // the internal parsers having to read ahead into the next (non-child) element. | |
| TEST_F(MasterParserTest, MultipleUnknownChildSize) { | |
| SetReaderData({ | |
| 0xA1, // ID = 0xA1 (Block) (master). | |
| 0xFF, // Size = unknown. | |
| 0xEC, // ID = 0xEC (Void) (child). | |
| 0x81, // Size = 1. | |
| 0x12, // Body. | |
| 0xA1, // ID = 0xA1 (Block) (master). | |
| 0xFF, // Size = unknown. | |
| 0xEC, // ID = 0xEC (Void) (child). | |
| 0x81, // Size = 1. | |
| 0x13, // Body. | |
| }); | |
| { | |
| InSequence dummy; | |
| ElementMetadata metadata = {Id::kBlock, 2, kUnknownElementSize, 0}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| metadata = {Id::kVoid, 2, 1, 2}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| EXPECT_CALL(callback_, OnVoid(metadata, NotNull(), NotNull())).Times(1); | |
| metadata = {Id::kBlock, 2, kUnknownElementSize, 5}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| metadata = {Id::kVoid, 2, 1, 7}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| EXPECT_CALL(callback_, OnVoid(metadata, NotNull(), NotNull())).Times(1); | |
| } | |
| ResetParser(ParserForId(Id::kBlock, new MasterParser)); | |
| ParseAndVerify(); | |
| } | |
| // Reaching the end of the file while reading an element with unknown size | |
| // should return Status::kOkCompleted instead of Status::kEndOfFile. | |
| TEST_F(MasterParserTest, UnknownSizeToFileEnd) { | |
| SetReaderData({ | |
| 0xEC, // ID = 0xEC (Void). | |
| 0x81, // Size = 1. | |
| 0x00, // Body. | |
| }); | |
| { | |
| InSequence dummy; | |
| const ElementMetadata metadata = {Id::kVoid, 2, 1, 0}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| EXPECT_CALL(callback_, OnVoid(metadata, NotNull(), NotNull())).Times(1); | |
| } | |
| ParseAndVerify(); | |
| } | |
| // Parsing one byte at a time is okay. | |
| TEST_F(MasterParserTest, IncrementalParse) { | |
| SetReaderData({ | |
| 0x1A, 0x45, 0xDF, 0xA3, // ID = 0x1A45DFA3 (EBML). | |
| 0x08, 0x00, 0x00, 0x00, 0x06, // Size = 6. | |
| 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, // Body. | |
| }); | |
| const ElementMetadata metadata = {Id::kEbml, 9, 6, 0}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| BinaryParser* binary_parser = new BinaryParser; | |
| ResetParser(ParserForId(Id::kEbml, binary_parser)); | |
| IncrementalParseAndVerify(); | |
| std::vector<std::uint8_t> expected = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06}; | |
| EXPECT_EQ(expected, binary_parser->value()); | |
| } | |
| // Alternating actions between skip and read is okay. The parser should remember | |
| // the requested action between repeated calls to Feed. | |
| TEST_F(MasterParserTest, IncrementalSkipThenReadThenSkip) { | |
| SetReaderData({ | |
| 0xA1, // ID = 0xA1 (Block) (master). | |
| 0x83, // Size = 3. | |
| 0xEC, // ID = 0xEC (Void) (child). | |
| 0x81, // Size = 1. | |
| 0x12, // Body. | |
| 0xA1, // ID = 0xA1 (Block) (master). | |
| 0x83, // Size = 3. | |
| 0xEC, // ID = 0xEC (Void) (child). | |
| 0x81, // Size = 1. | |
| 0x13, // Body. | |
| 0xA1, // ID = 0xA1 (Block) (master). | |
| 0xFF, // Size = unknown. | |
| 0xEC, // ID = 0xEC (Void) (child). | |
| 0x81, // Size = 1. | |
| 0x14, // Body. | |
| }); | |
| { | |
| InSequence dummy; | |
| ElementMetadata metadata = {Id::kBlock, 2, 3, 0}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())) | |
| .WillOnce(Return(Status(Status::kOkPartial))) | |
| .WillOnce(DoAll(SetArgPointee<1>(Action::kSkip), | |
| Return(Status(Status::kOkCompleted)))); | |
| metadata = {Id::kBlock, 2, 3, 5}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| metadata = {Id::kVoid, 2, 1, 7}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())).Times(1); | |
| // Expect to get called twice because we'll cap the LimitedReader to 1-byte | |
| // reads. The first attempt to read will fail because we'll have already | |
| // reached the 1-byte max. | |
| EXPECT_CALL(callback_, OnVoid(metadata, NotNull(), NotNull())).Times(2); | |
| metadata = {Id::kBlock, 2, kUnknownElementSize, 10}; | |
| EXPECT_CALL(callback_, OnElementBegin(metadata, NotNull())) | |
| .WillOnce(DoAll(SetArgPointee<1>(Action::kSkip), | |
| Return(Status(Status::kOkCompleted)))); | |
| } | |
| ResetParser(ParserForId(Id::kBlock, new MasterParser)); | |
| IncrementalParseAndVerify(); | |
| } | |
| } // namespace |