generic-library/webm
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

webm_parser: Enable usage of werror.

Browse Source 
Mass warning clean up. Mainly:
- Explicit casts of numeric literals to avoid signed/unsigned compare
  warnings.
- Commenting out of unused function arg names.

Change-Id: I0e70393a5743ae984035d43712c724d4ccd12f9d
This commit is contained in:
Tom Finegan
2016-08-08 14:47:42 -07:00
parent e1fe7627c8
commit d518128266
39 changed files with 346 additions and 324 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
webm_parser/demo/demo.cc
View File

@@ -965,13 +965,13 @@ class DemoCallback : public Callback {
return Status(Status::kOkCompleted);
}
Status OnSimpleBlockEnd(const ElementMetadata& metadata,
const SimpleBlock& simple_block) override {
Status OnSimpleBlockEnd(const ElementMetadata& /* metadata */,
const SimpleBlock& /* simple_block */) override {
return Status(Status::kOkCompleted);
}
Status OnBlockGroupBegin(const ElementMetadata& metadata,
Action* action) override {
Action* /* action */) override {
indent = 2;
PrintElementMetadata("BlockGroup", metadata);
return Status(Status::kOkCompleted);
@@ -991,12 +991,12 @@ class DemoCallback : public Callback {
return Status(Status::kOkCompleted);
}
Status OnBlockEnd(const ElementMetadata& metadata,
const Block& block) override {
Status OnBlockEnd(const ElementMetadata& /* metadata */,
const Block& /* block */) override {
return Status(Status::kOkCompleted);
}
Status OnBlockGroupEnd(const ElementMetadata& metadata,
Status OnBlockGroupEnd(const ElementMetadata& /* metadata */,
const BlockGroup& block_group) override {
if (block_group.virtual_block.is_present()) {
std::cout << std::string(indent * spaces_per_indent, ' ')
@@ -1027,8 +1027,8 @@ class DemoCallback : public Callback {
return Callback::OnFrame(metadata, reader, bytes_remaining);
}
Status OnClusterEnd(const ElementMetadata& metadata,
const Cluster& cluster) override {
Status OnClusterEnd(const ElementMetadata& /* metadata */,
const Cluster& /* cluster */) override {
// The Cluster and all its children have been fully parsed at this point. If
// the file wasn't properly muxed and Timecode or PrevSize were missing in
// OnClusterBegin(), they'll be set here (if the Cluster contained them). In
@@ -1090,7 +1090,7 @@ class DemoCallback : public Callback {
return Status(Status::kOkCompleted);
}
Status OnSegmentEnd(const ElementMetadata& metadata) override {
Status OnSegmentEnd(const ElementMetadata& /* metadata */) override {
return Status(Status::kOkCompleted);
}
};

8
webm_parser/src/block_parser.cc
View File

@@ -22,7 +22,7 @@ namespace {
// The ParseBasicBlockFlags functions parse extra flag bits into the block,
// depending on the type of block that is being parsed.
void ParseBasicBlockFlags(std::uint8_t flags, Block* block) {
void ParseBasicBlockFlags(std::uint8_t /* flags */, Block* /* block */) {
// Block has no extra flags that aren't already handled.
}
@@ -150,7 +150,7 @@ Status BasicBlockParser<T>::Feed(Callback* callback, Reader* reader,
case State::kReadingXiphLaceSizes:
assert(value_.num_frames > 0);
while (lace_sizes_.size() < value_.num_frames - 1) {
while (static_cast<int>(lace_sizes_.size()) < value_.num_frames - 1) {
std::uint8_t byte;
do {
status = ReadByte(reader, &byte);
@@ -185,7 +185,7 @@ Status BasicBlockParser<T>::Feed(Callback* callback, Reader* reader,
case State::kReadingEbmlLaceSizes:
assert(value_.num_frames > 0);
assert(!lace_sizes_.empty());
while (lace_sizes_.size() < value_.num_frames - 1) {
while (static_cast<int>(lace_sizes_.size()) < value_.num_frames - 1) {
status = uint_parser_.Feed(callback, reader, &local_num_bytes_read);
*num_bytes_read += local_num_bytes_read;
header_bytes_read_ += local_num_bytes_read;
@@ -250,7 +250,7 @@ Status BasicBlockParser<T>::Feed(Callback* callback, Reader* reader,
case State::kReadingFrames:
assert(value_.num_frames > 0);
assert(lace_sizes_.size() == value_.num_frames);
assert(static_cast<int>(lace_sizes_.size()) == value_.num_frames);
for (; current_lace_ < lace_sizes_.size(); ++current_lace_) {
const std::uint64_t original = lace_sizes_[current_lace_];
status = callback->OnFrame(frame_metadata_, reader,

66
webm_parser/src/callback.cc
View File

@@ -11,14 +11,14 @@
namespace webm {
Status Callback::OnElementBegin(const ElementMetadata& metadata,
Status Callback::OnElementBegin(const ElementMetadata& /* metadata */,
Action* action) {
assert(action != nullptr);
*action = Action::kRead;
return Status(Status::kOkCompleted);
}
Status Callback::OnUnknownElement(const ElementMetadata& metadata,
Status Callback::OnUnknownElement(const ElementMetadata& /* metadata */,
Reader* reader,
std::uint64_t* bytes_remaining) {
assert(reader != nullptr);
@@ -26,108 +26,112 @@ Status Callback::OnUnknownElement(const ElementMetadata& metadata,
return Skip(reader, bytes_remaining);
}
Status Callback::OnEbml(const ElementMetadata& metadata, const Ebml& ebml) {
Status Callback::OnEbml(const ElementMetadata& /* metadata */,
const Ebml& /* ebml */) {
return Status(Status::kOkCompleted);
}
Status Callback::OnVoid(const ElementMetadata& metadata, Reader* reader,
Status Callback::OnVoid(const ElementMetadata& /* metadata */, Reader* reader,
std::uint64_t* bytes_remaining) {
assert(reader != nullptr);
assert(bytes_remaining != nullptr);
return Skip(reader, bytes_remaining);
}
Status Callback::OnSegmentBegin(const ElementMetadata& metadata,
Status Callback::OnSegmentBegin(const ElementMetadata& /* metadata */,
Action* action) {
assert(action != nullptr);
*action = Action::kRead;
return Status(Status::kOkCompleted);
}
Status Callback::OnSeek(const ElementMetadata& metadata, const Seek& seek) {
Status Callback::OnSeek(const ElementMetadata& /* metadata */,
const Seek& /* seek */) {
return Status(Status::kOkCompleted);
}
Status Callback::OnInfo(const ElementMetadata& metadata, const Info& info) {
Status Callback::OnInfo(const ElementMetadata& /* metadata */,
const Info& /* info */) {
return Status(Status::kOkCompleted);
}
Status Callback::OnClusterBegin(const ElementMetadata& metadata,
const Cluster& cluster, Action* action) {
Status Callback::OnClusterBegin(const ElementMetadata& /* metadata */,
const Cluster& /* cluster */, Action* action) {
assert(action != nullptr);
*action = Action::kRead;
return Status(Status::kOkCompleted);
}
Status Callback::OnSimpleBlockBegin(const ElementMetadata& metadata,
const SimpleBlock& simple_block,
Status Callback::OnSimpleBlockBegin(const ElementMetadata& /* metadata */,
const SimpleBlock& /* simple_block */,
Action* action) {
assert(action != nullptr);
*action = Action::kRead;
return Status(Status::kOkCompleted);
}
Status Callback::OnSimpleBlockEnd(const ElementMetadata& metadata,
const SimpleBlock& simple_block) {
Status Callback::OnSimpleBlockEnd(const ElementMetadata& /* metadata */,
const SimpleBlock& /* simple_block */) {
return Status(Status::kOkCompleted);
}
Status Callback::OnBlockGroupBegin(const ElementMetadata& metadata,
Status Callback::OnBlockGroupBegin(const ElementMetadata& /* metadata */,
Action* action) {
assert(action != nullptr);
*action = Action::kRead;
return Status(Status::kOkCompleted);
}
Status Callback::OnBlockBegin(const ElementMetadata& metadata,
const Block& block, Action* action) {
Status Callback::OnBlockBegin(const ElementMetadata& /* metadata */,
const Block& /* block */, Action* action) {
assert(action != nullptr);
*action = Action::kRead;
return Status(Status::kOkCompleted);
}
Status Callback::OnBlockEnd(const ElementMetadata& metadata,
const Block& block) {
Status Callback::OnBlockEnd(const ElementMetadata& /* metadata */,
const Block& /* block */) {
return Status(Status::kOkCompleted);
}
Status Callback::OnBlockGroupEnd(const ElementMetadata& metadata,
const BlockGroup& block_group) {
Status Callback::OnBlockGroupEnd(const ElementMetadata& /* metadata */,
const BlockGroup& /* block_group */) {
return Status(Status::kOkCompleted);
}
Status Callback::OnFrame(const FrameMetadata& metadata, Reader* reader,
Status Callback::OnFrame(const FrameMetadata& /* metadata */, Reader* reader,
std::uint64_t* bytes_remaining) {
assert(reader != nullptr);
assert(bytes_remaining != nullptr);
return Skip(reader, bytes_remaining);
}
Status Callback::OnClusterEnd(const ElementMetadata& metadata,
const Cluster& cluster) {
Status Callback::OnClusterEnd(const ElementMetadata& /* metadata */,
const Cluster& /* cluster */) {
return Status(Status::kOkCompleted);
}
Status Callback::OnTrackEntry(const ElementMetadata& metadata,
const TrackEntry& track_entry) {
Status Callback::OnTrackEntry(const ElementMetadata& /* metadata */,
const TrackEntry& /* track_entry */) {
return Status(Status::kOkCompleted);
}
Status Callback::OnCuePoint(const ElementMetadata& metadata,
const CuePoint& cue_point) {
Status Callback::OnCuePoint(const ElementMetadata& /* metadata */,
const CuePoint& /* cue_point */) {
return Status(Status::kOkCompleted);
}
Status Callback::OnEditionEntry(const ElementMetadata& metadata,
const EditionEntry& edition_entry) {
Status Callback::OnEditionEntry(const ElementMetadata& /* metadata */,
const EditionEntry& /* edition_entry */) {
return Status(Status::kOkCompleted);
}
Status Callback::OnTag(const ElementMetadata& metadata, const Tag& tag) {
Status Callback::OnTag(const ElementMetadata& /* metadata */,
const Tag& /* tag */) {
return Status(Status::kOkCompleted);
}
Status Callback::OnSegmentEnd(const ElementMetadata& metadata) {
Status Callback::OnSegmentEnd(const ElementMetadata& /* metadata */) {
return Status(Status::kOkCompleted);
}

4
webm_parser/src/element_parser.h
View File

@@ -71,8 +71,8 @@ class ElementParser : public Parser {
// this parser is the first element in child_ancestory, or if that is empty,
// then child_metadata itself. If the child is not a valid child of this
// parser, then a debug assertion is made (because that indicates a bug).
virtual void InitAfterSeek(const Ancestory& child_ancestory,
const ElementMetadata& child_metadata) {
virtual void InitAfterSeek(const Ancestory& /* child_ancestory */,
const ElementMetadata& /* child_metadata */) {
assert(false);
}

2
webm_parser/src/istream_reader.cc
View File

@@ -62,7 +62,7 @@ Status IstreamReader::Read(std::size_t num_to_read, std::uint8_t* buffer,
return Status(Status::kEndOfFile);
}
if (actual == num_to_read) {
if (static_cast<std::size_t>(actual) == num_to_read) {
return Status(Status::kOkCompleted);
} else {
return Status(Status::kOkPartial);

2
webm_parser/src/master_value_parser.h
View File

@@ -325,7 +325,7 @@ class MasterValueParser : public ElementParser {
// parsed for which NotifyOnParseComplete() was requested. The provided
// metadata is for the child element that has just completed parsing. By
// default this method does nothing.
virtual void OnChildParsed(const ElementMetadata& metadata) {}
virtual void OnChildParsed(const ElementMetadata& /* metadata */) {}
private:
T value_;

4
webm_parser/src/parser_utils.h
View File

@@ -38,11 +38,11 @@ Status AccumulateIntegerBytes(int num_to_read, Reader* reader, T* integer,
assert(integer != nullptr);
assert(num_actually_read != nullptr);
assert(num_to_read >= 0);
assert(num_to_read <= sizeof(T));
assert(static_cast<std::size_t>(num_to_read) <= sizeof(T));
*num_actually_read = 0;
if (num_to_read < 0 || num_to_read > sizeof(T)) {
if (num_to_read < 0 || static_cast<std::size_t>(num_to_read) > sizeof(T)) {
return Status(Status::kInvalidElementSize);
}

18
webm_parser/src/skip_callback.h
View File

@@ -20,39 +20,39 @@ namespace webm {
// if the callback ever needs to process data from the byte stream.
class SkipCallback : public Callback {
public:
Status OnElementBegin(const ElementMetadata& metadata,
Status OnElementBegin(const ElementMetadata& /* metadata */,
Action* action) override {
*action = Action::kSkip;
return Status(Status::kOkCompleted);
}
Status OnSegmentBegin(const ElementMetadata& metadata,
Status OnSegmentBegin(const ElementMetadata& /* metadata */,
Action* action) override {
*action = Action::kSkip;
return Status(Status::kOkCompleted);
}
Status OnClusterBegin(const ElementMetadata& metadata, const Cluster& cluster,
Action* action) override {
Status OnClusterBegin(const ElementMetadata& /* metadata */,
const Cluster& /* cluster */, Action* action) override {
*action = Action::kSkip;
return Status(Status::kOkCompleted);
}
Status OnSimpleBlockBegin(const ElementMetadata& metadata,
const SimpleBlock& simple_block,
Status OnSimpleBlockBegin(const ElementMetadata& /* metadata */,
const SimpleBlock& /* simple_block */,
Action* action) override {
*action = Action::kSkip;
return Status(Status::kOkCompleted);
}
Status OnBlockGroupBegin(const ElementMetadata& metadata,
Status OnBlockGroupBegin(const ElementMetadata& /* metadata */,
Action* action) override {
*action = Action::kSkip;
return Status(Status::kOkCompleted);
}
Status OnBlockBegin(const ElementMetadata& metadata, const Block& block,
Action* action) override {
Status OnBlockBegin(const ElementMetadata& /* metadata */,
const Block& /* block */, Action* action) override {
*action = Action::kSkip;
return Status(Status::kOkCompleted);
}

2
webm_parser/test_utils/element_parser_test.h
View File

@@ -71,7 +71,7 @@ class ElementParserTest : public ParserTest<T> {
std::uint64_t local_num_bytes_read = 0;
status = parser_.Feed(&callback_, &limited_reader, &local_num_bytes_read);
num_bytes_read += local_num_bytes_read;
ASSERT_GE(1, local_num_bytes_read);
ASSERT_GE(static_cast<std::uint64_t>(1), local_num_bytes_read);
} while (status.code == Status::kWouldBlock ||
status.code == Status::kOkPartial);

3
webm_parser/test_utils/parser_test.h
View File

@@ -71,7 +71,8 @@ class ParserTest : public testing::Test {
std::uint64_t local_num_bytes_read = 0;
status = parser_.Feed(&callback_, &limited_reader, &local_num_bytes_read);
num_bytes_read += local_num_bytes_read;
ASSERT_GE(1, local_num_bytes_read);
const std::uint64_t kMinBytesRead = 1;
ASSERT_GE(kMinBytesRead, local_num_bytes_read);
} while (status.code == Status::kWouldBlock ||
status.code == Status::kOkPartial);

30
webm_parser/tests/audio_parser_test.cc
View File

@@ -33,10 +33,10 @@ TEST_F(AudioParserTest, DefaultParse) {
EXPECT_EQ(8000, audio.output_frequency.value());
EXPECT_FALSE(audio.channels.is_present());
EXPECT_EQ(1, audio.channels.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), audio.channels.value());
EXPECT_FALSE(audio.bit_depth.is_present());
EXPECT_EQ(0, audio.bit_depth.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), audio.bit_depth.value());
}
TEST_F(AudioParserTest, DefaultValues) {
@@ -65,10 +65,10 @@ TEST_F(AudioParserTest, DefaultValues) {
EXPECT_EQ(8000, audio.output_frequency.value());
EXPECT_TRUE(audio.channels.is_present());
EXPECT_EQ(1, audio.channels.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), audio.channels.value());
EXPECT_TRUE(audio.bit_depth.is_present());
EXPECT_EQ(0, audio.bit_depth.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), audio.bit_depth.value());
}
TEST_F(AudioParserTest, CustomValues) {
@@ -95,16 +95,16 @@ TEST_F(AudioParserTest, CustomValues) {
const Audio audio = parser_.value();
EXPECT_TRUE(audio.sampling_frequency.is_present());
EXPECT_EQ(1, audio.sampling_frequency.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), audio.sampling_frequency.value());
EXPECT_TRUE(audio.output_frequency.is_present());
EXPECT_EQ(1.73205077648162841796875, audio.output_frequency.value());
EXPECT_TRUE(audio.channels.is_present());
EXPECT_EQ(2, audio.channels.value());
EXPECT_EQ(static_cast<std::uint64_t>(2), audio.channels.value());
EXPECT_TRUE(audio.bit_depth.is_present());
EXPECT_EQ(1, audio.bit_depth.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), audio.bit_depth.value());
}
TEST_F(AudioParserTest, AbsentOutputSamplingFrequency) {
@@ -119,16 +119,16 @@ TEST_F(AudioParserTest, AbsentOutputSamplingFrequency) {
const Audio audio = parser_.value();
EXPECT_TRUE(audio.sampling_frequency.is_present());
EXPECT_EQ(1, audio.sampling_frequency.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), audio.sampling_frequency.value());
EXPECT_FALSE(audio.output_frequency.is_present());
EXPECT_EQ(1, audio.output_frequency.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), audio.output_frequency.value());
EXPECT_FALSE(audio.channels.is_present());
EXPECT_EQ(1, audio.channels.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), audio.channels.value());
EXPECT_FALSE(audio.bit_depth.is_present());
EXPECT_EQ(0, audio.bit_depth.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), audio.bit_depth.value());
}
TEST_F(AudioParserTest, DefaultOutputSamplingFrequency) {
@@ -146,16 +146,16 @@ TEST_F(AudioParserTest, DefaultOutputSamplingFrequency) {
const Audio audio = parser_.value();
EXPECT_TRUE(audio.sampling_frequency.is_present());
EXPECT_EQ(1, audio.sampling_frequency.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), audio.sampling_frequency.value());
EXPECT_TRUE(audio.output_frequency.is_present());
EXPECT_EQ(1, audio.output_frequency.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), audio.output_frequency.value());
EXPECT_FALSE(audio.channels.is_present());
EXPECT_EQ(1, audio.channels.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), audio.channels.value());
EXPECT_FALSE(audio.bit_depth.is_present());
EXPECT_EQ(0, audio.bit_depth.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), audio.bit_depth.value());
}
} // namespace

7
webm_parser/tests/block_additions_parser_test.cc
View File

@@ -28,7 +28,8 @@ TEST_F(BlockAdditionsParserTest, DefaultParse) {
const BlockAdditions block_additions = parser_.value();
EXPECT_EQ(0, block_additions.block_mores.size());
const std::size_t kExpectedBlockMoresSize = 0;
EXPECT_EQ(kExpectedBlockMoresSize, block_additions.block_mores.size());
}
TEST_F(BlockAdditionsParserTest, DefaultValues) {
@@ -41,7 +42,7 @@ TEST_F(BlockAdditionsParserTest, DefaultValues) {
const BlockAdditions block_additions = parser_.value();
ASSERT_EQ(1, block_additions.block_mores.size());
ASSERT_EQ(static_cast<std::size_t>(1), block_additions.block_mores.size());
EXPECT_TRUE(block_additions.block_mores[0].is_present());
EXPECT_EQ(BlockMore{}, block_additions.block_mores[0].value());
}
@@ -69,7 +70,7 @@ TEST_F(BlockAdditionsParserTest, CustomValues) {
BlockMore expected;
ASSERT_EQ(2, block_additions.block_mores.size());
ASSERT_EQ(static_cast<std::size_t>(2), block_additions.block_mores.size());
expected.id.Set(2, true);
EXPECT_TRUE(block_additions.block_mores[0].is_present());
EXPECT_EQ(expected, block_additions.block_mores[0].value());

4
webm_parser/tests/block_header_parser_test.cc
View File

@@ -31,7 +31,7 @@ TEST_F(BlockHeaderParserTest, ValidBlock) {
const BlockHeader& block_header = parser_.value();
EXPECT_EQ(1, block_header.track_number);
EXPECT_EQ(static_cast<std::uint64_t>(1), block_header.track_number);
EXPECT_EQ(0x1234, block_header.timecode);
EXPECT_EQ(0x00, block_header.flags);
}
@@ -47,7 +47,7 @@ TEST_F(BlockHeaderParserTest, IncrementalParse) {
const BlockHeader& block_header = parser_.value();
EXPECT_EQ(2, block_header.track_number);
EXPECT_EQ(static_cast<std::uint64_t>(2), block_header.track_number);
EXPECT_EQ(-2, block_header.timecode);
EXPECT_EQ(0xFF, block_header.flags);
}

6
webm_parser/tests/block_more_parser_test.cc
View File

@@ -28,7 +28,7 @@ TEST_F(BlockMoreParserTest, DefaultParse) {
const BlockMore block_more = parser_.value();
EXPECT_FALSE(block_more.id.is_present());
EXPECT_EQ(1, block_more.id.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), block_more.id.value());
EXPECT_FALSE(block_more.data.is_present());
EXPECT_EQ(std::vector<std::uint8_t>{}, block_more.data.value());
@@ -48,7 +48,7 @@ TEST_F(BlockMoreParserTest, DefaultValues) {
const BlockMore block_more = parser_.value();
EXPECT_TRUE(block_more.id.is_present());
EXPECT_EQ(1, block_more.id.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), block_more.id.value());
EXPECT_TRUE(block_more.data.is_present());
EXPECT_EQ(std::vector<std::uint8_t>{}, block_more.data.value());
@@ -70,7 +70,7 @@ TEST_F(BlockMoreParserTest, CustomValues) {
const BlockMore block_more = parser_.value();
EXPECT_TRUE(block_more.id.is_present());
EXPECT_EQ(2, block_more.id.value());
EXPECT_EQ(static_cast<std::uint64_t>(2), block_more.id.value());
EXPECT_TRUE(block_more.data.is_present());
EXPECT_EQ(std::vector<std::uint8_t>{0x00}, block_more.data.value());

7
webm_parser/tests/block_parser_test.cc
View File

@@ -547,10 +547,11 @@ class BasicBlockParserTest : public ElementParserTest<T, id> {
// Incremental parsing will call OnFrame once for every byte, plus
// maybe one more time if the first call reads zero bytes (if the reader
// is
// blocked).
// is blocked).
const int this_frame_size = static_cast<int>(frame_size);
EXPECT_CALL(callback_, OnFrame(metadata, NotNull(), NotNull()))
.Times(incremental ? Between(frame_size, frame_size + 1) : Exactly(1))
.Times(incremental ? Between(this_frame_size, this_frame_size + 1) :
Exactly(1))
.WillRepeatedly(Invoke(frame_handler));
metadata.position += metadata.size;

47
webm_parser/tests/buffer_reader_test.cc
View File

@@ -26,23 +26,24 @@ TEST_F(BufferReaderTest, Assignment) {
Status status;
BufferReader reader({});
EXPECT_EQ(0, reader.size());
const std::size_t kExpectedSize = 0;
EXPECT_EQ(kExpectedSize, reader.size());
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(Status::kEndOfFile, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(static_cast<std::uint64_t>(0), count);
reader = {1, 2, 3, 4};
EXPECT_EQ(4, reader.size());
EXPECT_EQ(static_cast<std::size_t>(4), reader.size());
status = reader.Read(2, buffer.data(), &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
reader = {5, 6, 7, 8};
status = reader.Read(2, buffer.data() + 2, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
std::array<std::uint8_t, 4> expected = {{1, 2, 5, 6}};
EXPECT_EQ(expected, buffer);
@@ -58,11 +59,11 @@ TEST_F(BufferReaderTest, Empty) {
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(Status::kEndOfFile, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(static_cast<std::uint64_t>(0), count);
status = reader.Skip(1, &count);
EXPECT_EQ(Status::kEndOfFile, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(static_cast<std::uint64_t>(0), count);
}
TEST_F(BufferReaderTest, Read) {
@@ -75,18 +76,18 @@ TEST_F(BufferReaderTest, Read) {
status = reader.Read(5, buffer.data(), &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(5, count);
EXPECT_EQ(static_cast<std::uint64_t>(5), count);
status = reader.Read(10, buffer.data() + 5, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(5, count);
EXPECT_EQ(static_cast<std::uint64_t>(5), count);
std::array<std::uint8_t, 15> expected = {{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}};
EXPECT_EQ(expected, buffer);
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(Status::kEndOfFile, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(static_cast<std::uint64_t>(0), count);
}
TEST_F(BufferReaderTest, Skip) {
@@ -98,15 +99,15 @@ TEST_F(BufferReaderTest, Skip) {
status = reader.Skip(3, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(3, count);
EXPECT_EQ(static_cast<std::uint64_t>(3), count);
status = reader.Skip(10, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(7, count);
EXPECT_EQ(static_cast<std::uint64_t>(7), count);
status = reader.Skip(1, &count);
EXPECT_EQ(Status::kEndOfFile, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(static_cast<std::uint64_t>(0), count);
}
TEST_F(BufferReaderTest, ReadAndSkip) {
@@ -120,15 +121,15 @@ TEST_F(BufferReaderTest, ReadAndSkip) {
status = reader.Read(5, buffer.data(), &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(5, count);
EXPECT_EQ(static_cast<std::uint64_t>(5), count);
status = reader.Skip(3, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(3, count);
EXPECT_EQ(static_cast<std::uint64_t>(3), count);
status = reader.Read(5, buffer.data() + 5, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
std::array<std::uint8_t, 10> expected = {{9, 8, 7, 6, 5, 1, 0, 0, 0, 0}};
EXPECT_EQ(expected, buffer);
@@ -140,22 +141,22 @@ TEST_F(BufferReaderTest, Position) {
Status status;
BufferReader reader({9, 8, 7, 6, 5, 4, 3, 2, 1, 0});
EXPECT_EQ(0, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(0), reader.Position());
status = reader.Read(5, buffer.data(), &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(5, count);
EXPECT_EQ(5, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(5), count);
EXPECT_EQ(static_cast<std::uint64_t>(5), reader.Position());
status = reader.Skip(3, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(3, count);
EXPECT_EQ(8, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(3), count);
EXPECT_EQ(static_cast<std::uint64_t>(8), reader.Position());
status = reader.Read(5, buffer.data() + 5, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(10, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
EXPECT_EQ(static_cast<std::uint64_t>(10), reader.Position());
std::array<std::uint8_t, 10> expected = {{9, 8, 7, 6, 5, 1, 0, 0, 0, 0}};
EXPECT_EQ(expected, buffer);

2
webm_parser/tests/callback_test.cc
View File

@@ -78,7 +78,7 @@ void TestRead(Status (Callback::*function)(const T&, Reader*, std::uint64_t*)) {
status = (callback.*function)(metadata, &reader, &bytes_remaining);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(0, bytes_remaining);
EXPECT_EQ(static_cast<std::uint64_t>(0), bytes_remaining);
}
class CallbackTest : public testing::Test {};

30
webm_parser/tests/chapter_atom_parser_test.cc
View File

@@ -29,20 +29,20 @@ TEST_F(ChapterAtomParserTest, DefaultParse) {
const ChapterAtom chapter_atom = parser_.value();
EXPECT_FALSE(chapter_atom.uid.is_present());
EXPECT_EQ(0, chapter_atom.uid.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), chapter_atom.uid.value());
EXPECT_FALSE(chapter_atom.string_uid.is_present());
EXPECT_EQ("", chapter_atom.string_uid.value());
EXPECT_FALSE(chapter_atom.time_start.is_present());
EXPECT_EQ(0, chapter_atom.time_start.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), chapter_atom.time_start.value());
EXPECT_FALSE(chapter_atom.time_end.is_present());
EXPECT_EQ(0, chapter_atom.time_end.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), chapter_atom.time_end.value());
EXPECT_EQ(0, chapter_atom.displays.size());
EXPECT_EQ(static_cast<std::size_t>(0), chapter_atom.displays.size());
EXPECT_EQ(0, chapter_atom.atoms.size());
EXPECT_EQ(static_cast<std::uint64_t>(0), chapter_atom.atoms.size());
}
TEST_F(ChapterAtomParserTest, DefaultValues) {
@@ -71,22 +71,22 @@ TEST_F(ChapterAtomParserTest, DefaultValues) {
const ChapterAtom chapter_atom = parser_.value();
EXPECT_TRUE(chapter_atom.uid.is_present());
EXPECT_EQ(0, chapter_atom.uid.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), chapter_atom.uid.value());
EXPECT_TRUE(chapter_atom.string_uid.is_present());
EXPECT_EQ("", chapter_atom.string_uid.value());
EXPECT_TRUE(chapter_atom.time_start.is_present());
EXPECT_EQ(0, chapter_atom.time_start.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), chapter_atom.time_start.value());
EXPECT_TRUE(chapter_atom.time_end.is_present());
EXPECT_EQ(0, chapter_atom.time_end.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), chapter_atom.time_end.value());
ASSERT_EQ(1, chapter_atom.displays.size());
ASSERT_EQ(static_cast<std::uint64_t>(1), chapter_atom.displays.size());
EXPECT_TRUE(chapter_atom.displays[0].is_present());
EXPECT_EQ(ChapterDisplay{}, chapter_atom.displays[0].value());
ASSERT_EQ(1, chapter_atom.atoms.size());
ASSERT_EQ(static_cast<std::uint64_t>(1), chapter_atom.atoms.size());
EXPECT_TRUE(chapter_atom.atoms[0].is_present());
EXPECT_EQ(ChapterAtom{}, chapter_atom.atoms[0].value());
}
@@ -150,20 +150,20 @@ TEST_F(ChapterAtomParserTest, CustomValues) {
const ChapterAtom chapter_atom = parser_.value();
EXPECT_TRUE(chapter_atom.uid.is_present());
EXPECT_EQ(1, chapter_atom.uid.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), chapter_atom.uid.value());
EXPECT_TRUE(chapter_atom.string_uid.is_present());
EXPECT_EQ("A", chapter_atom.string_uid.value());
EXPECT_TRUE(chapter_atom.time_start.is_present());
EXPECT_EQ(2, chapter_atom.time_start.value());
EXPECT_EQ(static_cast<std::uint64_t>(2), chapter_atom.time_start.value());
EXPECT_TRUE(chapter_atom.time_end.is_present());
EXPECT_EQ(3, chapter_atom.time_end.value());
EXPECT_EQ(static_cast<std::uint64_t>(3), chapter_atom.time_end.value());
ChapterDisplay expected_chapter_display;
ASSERT_EQ(2, chapter_atom.displays.size());
ASSERT_EQ(static_cast<std::size_t>(2), chapter_atom.displays.size());
expected_chapter_display.string.Set("B", true);
EXPECT_TRUE(chapter_atom.displays[0].is_present());
EXPECT_EQ(expected_chapter_display, chapter_atom.displays[0].value());
@@ -180,7 +180,7 @@ TEST_F(ChapterAtomParserTest, CustomValues) {
tmp_atom.uid.Set(6, true);
expected_chapter_atom.atoms.emplace_back(tmp_atom, true);
ASSERT_EQ(1, chapter_atom.atoms.size());
ASSERT_EQ(static_cast<std::size_t>(1), chapter_atom.atoms.size());
EXPECT_TRUE(chapter_atom.atoms[0].is_present());
EXPECT_EQ(expected_chapter_atom, chapter_atom.atoms[0].value());
}

12
webm_parser/tests/chapter_display_parser_test.cc
View File

@@ -30,11 +30,11 @@ TEST_F(ChapterDisplayParserTest, DefaultParse) {
EXPECT_FALSE(chapter_display.string.is_present());
EXPECT_EQ("", chapter_display.string.value());
ASSERT_EQ(1, chapter_display.languages.size());
ASSERT_EQ(static_cast<std::uint64_t>(1), chapter_display.languages.size());
EXPECT_FALSE(chapter_display.languages[0].is_present());
EXPECT_EQ("eng", chapter_display.languages[0].value());
EXPECT_EQ(0, chapter_display.countries.size());
EXPECT_EQ(static_cast<std::size_t>(0), chapter_display.countries.size());
}
TEST_F(ChapterDisplayParserTest, DefaultValues) {
@@ -56,11 +56,11 @@ TEST_F(ChapterDisplayParserTest, DefaultValues) {
EXPECT_TRUE(chapter_display.string.is_present());
EXPECT_EQ("", chapter_display.string.value());
ASSERT_EQ(1, chapter_display.languages.size());
ASSERT_EQ(static_cast<std::size_t>(1), chapter_display.languages.size());
EXPECT_TRUE(chapter_display.languages[0].is_present());
EXPECT_EQ("eng", chapter_display.languages[0].value());
ASSERT_EQ(1, chapter_display.countries.size());
ASSERT_EQ(static_cast<std::size_t>(1), chapter_display.countries.size());
EXPECT_TRUE(chapter_display.countries[0].is_present());
EXPECT_EQ("", chapter_display.countries[0].value());
}
@@ -99,7 +99,7 @@ TEST_F(ChapterDisplayParserTest, CustomValues) {
EXPECT_TRUE(chapter_display.string.is_present());
EXPECT_EQ("hello", chapter_display.string.value());
ASSERT_EQ(3, chapter_display.languages.size());
ASSERT_EQ(static_cast<std::size_t>(3), chapter_display.languages.size());
EXPECT_TRUE(chapter_display.languages[0].is_present());
EXPECT_EQ("lang0", chapter_display.languages[0].value());
EXPECT_TRUE(chapter_display.languages[1].is_present());
@@ -107,7 +107,7 @@ TEST_F(ChapterDisplayParserTest, CustomValues) {
EXPECT_TRUE(chapter_display.languages[2].is_present());
EXPECT_EQ("lang2", chapter_display.languages[2].value());
ASSERT_EQ(2, chapter_display.countries.size());
ASSERT_EQ(static_cast<std::size_t>(2), chapter_display.countries.size());
EXPECT_TRUE(chapter_display.countries[0].is_present());
EXPECT_EQ("area0", chapter_display.countries[0].value());
EXPECT_TRUE(chapter_display.countries[1].is_present());

54
webm_parser/tests/colour_parser_test.cc
View File

@@ -36,25 +36,25 @@ TEST_F(ColourParserTest, DefaultParse) {
colour.matrix_coefficients.value());
EXPECT_FALSE(colour.bits_per_channel.is_present());
EXPECT_EQ(0, colour.bits_per_channel.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.bits_per_channel.value());
EXPECT_FALSE(colour.chroma_subsampling_x.is_present());
EXPECT_EQ(0, colour.chroma_subsampling_x.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.chroma_subsampling_x.value());
EXPECT_FALSE(colour.chroma_subsampling_y.is_present());
EXPECT_EQ(0, colour.chroma_subsampling_y.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.chroma_subsampling_y.value());
EXPECT_FALSE(colour.cb_subsampling_x.is_present());
EXPECT_EQ(0, colour.cb_subsampling_x.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.cb_subsampling_x.value());
EXPECT_FALSE(colour.cb_subsampling_y.is_present());
EXPECT_EQ(0, colour.cb_subsampling_y.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.cb_subsampling_y.value());
EXPECT_FALSE(colour.chroma_siting_x.is_present());
EXPECT_EQ(0, colour.chroma_siting_x.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.chroma_siting_x.value());
EXPECT_FALSE(colour.chroma_siting_y.is_present());
EXPECT_EQ(0, colour.chroma_siting_y.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.chroma_siting_y.value());
EXPECT_FALSE(colour.range.is_present());
EXPECT_EQ(Range::kUnspecified, colour.range.value());
@@ -67,10 +67,10 @@ TEST_F(ColourParserTest, DefaultParse) {
EXPECT_EQ(Primaries::kUnspecified, colour.primaries.value());
EXPECT_FALSE(colour.max_cll.is_present());
EXPECT_EQ(0, colour.max_cll.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.max_cll.value());
EXPECT_FALSE(colour.max_fall.is_present());
EXPECT_EQ(0, colour.max_fall.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.max_fall.value());
EXPECT_FALSE(colour.mastering_metadata.is_present());
EXPECT_EQ(MasteringMetadata{}, colour.mastering_metadata.value());
@@ -130,25 +130,25 @@ TEST_F(ColourParserTest, DefaultValues) {
colour.matrix_coefficients.value());
EXPECT_TRUE(colour.bits_per_channel.is_present());
EXPECT_EQ(0, colour.bits_per_channel.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.bits_per_channel.value());
EXPECT_TRUE(colour.chroma_subsampling_x.is_present());
EXPECT_EQ(0, colour.chroma_subsampling_x.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.chroma_subsampling_x.value());
EXPECT_TRUE(colour.chroma_subsampling_y.is_present());
EXPECT_EQ(0, colour.chroma_subsampling_y.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.chroma_subsampling_y.value());
EXPECT_TRUE(colour.cb_subsampling_x.is_present());
EXPECT_EQ(0, colour.cb_subsampling_x.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.cb_subsampling_x.value());
EXPECT_TRUE(colour.cb_subsampling_y.is_present());
EXPECT_EQ(0, colour.cb_subsampling_y.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.cb_subsampling_y.value());
EXPECT_TRUE(colour.chroma_siting_x.is_present());
EXPECT_EQ(0, colour.chroma_siting_x.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.chroma_siting_x.value());
EXPECT_TRUE(colour.chroma_siting_y.is_present());
EXPECT_EQ(0, colour.chroma_siting_y.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.chroma_siting_y.value());
EXPECT_TRUE(colour.range.is_present());
EXPECT_EQ(Range::kUnspecified, colour.range.value());
@@ -161,10 +161,10 @@ TEST_F(ColourParserTest, DefaultValues) {
EXPECT_EQ(Primaries::kUnspecified, colour.primaries.value());
EXPECT_TRUE(colour.max_cll.is_present());
EXPECT_EQ(0, colour.max_cll.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.max_cll.value());
EXPECT_TRUE(colour.max_fall.is_present());
EXPECT_EQ(0, colour.max_fall.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), colour.max_fall.value());
EXPECT_TRUE(colour.mastering_metadata.is_present());
EXPECT_EQ(MasteringMetadata{}, colour.mastering_metadata.value());
@@ -240,25 +240,25 @@ TEST_F(ColourParserTest, CustomValues) {
EXPECT_EQ(MatrixCoefficients::kBt709, colour.matrix_coefficients.value());
EXPECT_TRUE(colour.bits_per_channel.is_present());
EXPECT_EQ(2, colour.bits_per_channel.value());
EXPECT_EQ(static_cast<std::uint64_t>(2), colour.bits_per_channel.value());
EXPECT_TRUE(colour.chroma_subsampling_x.is_present());
EXPECT_EQ(3, colour.chroma_subsampling_x.value());
EXPECT_EQ(static_cast<std::uint64_t>(3), colour.chroma_subsampling_x.value());
EXPECT_TRUE(colour.chroma_subsampling_y.is_present());
EXPECT_EQ(4, colour.chroma_subsampling_y.value());
EXPECT_EQ(static_cast<std::uint64_t>(4), colour.chroma_subsampling_y.value());
EXPECT_TRUE(colour.cb_subsampling_x.is_present());
EXPECT_EQ(5, colour.cb_subsampling_x.value());
EXPECT_EQ(static_cast<std::uint64_t>(5), colour.cb_subsampling_x.value());
EXPECT_TRUE(colour.cb_subsampling_y.is_present());
EXPECT_EQ(6, colour.cb_subsampling_y.value());
EXPECT_EQ(static_cast<std::uint64_t>(6), colour.cb_subsampling_y.value());
EXPECT_TRUE(colour.chroma_siting_x.is_present());
EXPECT_EQ(1, colour.chroma_siting_x.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), colour.chroma_siting_x.value());
EXPECT_TRUE(colour.chroma_siting_y.is_present());
EXPECT_EQ(2, colour.chroma_siting_y.value());
EXPECT_EQ(static_cast<std::uint64_t>(2), colour.chroma_siting_y.value());
EXPECT_TRUE(colour.range.is_present());
EXPECT_EQ(Range::kDerived, colour.range.value());
@@ -271,10 +271,10 @@ TEST_F(ColourParserTest, CustomValues) {
EXPECT_EQ(Primaries::kBt470Bg, colour.primaries.value());
EXPECT_TRUE(colour.max_cll.is_present());
EXPECT_EQ(6, colour.max_cll.value());
EXPECT_EQ(static_cast<std::uint64_t>(6), colour.max_cll.value());
EXPECT_TRUE(colour.max_fall.is_present());
EXPECT_EQ(7, colour.max_fall.value());
EXPECT_EQ(static_cast<std::uint64_t>(7), colour.max_fall.value());
MasteringMetadata mastering_metadata{};
mastering_metadata.primary_r_chromaticity_x.Set(1.0, true);

12
webm_parser/tests/content_encoding_parser_test.cc
View File

@@ -31,10 +31,10 @@ TEST_F(ContentEncodingParserTest, DefaultParse) {
const ContentEncoding content_encoding = parser_.value();
EXPECT_FALSE(content_encoding.order.is_present());
EXPECT_EQ(0, content_encoding.order.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), content_encoding.order.value());
EXPECT_FALSE(content_encoding.scope.is_present());
EXPECT_EQ(1, content_encoding.scope.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), content_encoding.scope.value());
EXPECT_FALSE(content_encoding.type.is_present());
EXPECT_EQ(ContentEncodingType::kCompression, content_encoding.type.value());
@@ -63,10 +63,10 @@ TEST_F(ContentEncodingParserTest, DefaultValues) {
const ContentEncoding content_encoding = parser_.value();
EXPECT_TRUE(content_encoding.order.is_present());
EXPECT_EQ(0, content_encoding.order.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), content_encoding.order.value());
EXPECT_TRUE(content_encoding.scope.is_present());
EXPECT_EQ(1, content_encoding.scope.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), content_encoding.scope.value());
EXPECT_TRUE(content_encoding.type.is_present());
EXPECT_EQ(ContentEncodingType::kCompression, content_encoding.type.value());
@@ -102,10 +102,10 @@ TEST_F(ContentEncodingParserTest, CustomValues) {
const ContentEncoding content_encoding = parser_.value();
EXPECT_TRUE(content_encoding.order.is_present());
EXPECT_EQ(1, content_encoding.order.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), content_encoding.order.value());
EXPECT_TRUE(content_encoding.scope.is_present());
EXPECT_EQ(2, content_encoding.scope.value());
EXPECT_EQ(static_cast<std::uint64_t>(2), content_encoding.scope.value());
EXPECT_TRUE(content_encoding.type.is_present());
EXPECT_EQ(ContentEncodingType::kEncryption, content_encoding.type.value());

6
webm_parser/tests/content_encodings_parser_test.cc
View File

@@ -29,7 +29,7 @@ TEST_F(ContentEncodingsParserTest, DefaultParse) {
const ContentEncodings content_encodings = parser_.value();
EXPECT_EQ(0, content_encodings.encodings.size());
EXPECT_EQ(static_cast<std::size_t>(0), content_encodings.encodings.size());
}
TEST_F(ContentEncodingsParserTest, DefaultValues) {
@@ -42,7 +42,7 @@ TEST_F(ContentEncodingsParserTest, DefaultValues) {
const ContentEncodings content_encodings = parser_.value();
ASSERT_EQ(1, content_encodings.encodings.size());
ASSERT_EQ(static_cast<std::size_t>(1), content_encodings.encodings.size());
EXPECT_TRUE(content_encodings.encodings[0].is_present());
EXPECT_EQ(ContentEncoding{}, content_encodings.encodings[0].value());
}
@@ -70,7 +70,7 @@ TEST_F(ContentEncodingsParserTest, CustomValues) {
ContentEncoding expected;
ASSERT_EQ(2, content_encodings.encodings.size());
ASSERT_EQ(static_cast<std::size_t>(2), content_encodings.encodings.size());
expected.order.Set(1, true);
EXPECT_TRUE(content_encodings.encodings[0].is_present());
EXPECT_EQ(expected, content_encodings.encodings[0].value());

42
webm_parser/tests/cue_track_positions_parser_test.cc
View File

@@ -29,19 +29,23 @@ TEST_F(CueTrackPositionsParserTest, DefaultParse) {
const CueTrackPositions cue_track_positions = parser_.value();
EXPECT_FALSE(cue_track_positions.track.is_present());
EXPECT_EQ(0, cue_track_positions.track.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), cue_track_positions.track.value());
EXPECT_FALSE(cue_track_positions.cluster_position.is_present());
EXPECT_EQ(0, cue_track_positions.cluster_position.value());
EXPECT_EQ(static_cast<std::uint64_t>(0),
cue_track_positions.cluster_position.value());
EXPECT_FALSE(cue_track_positions.relative_position.is_present());
EXPECT_EQ(0, cue_track_positions.relative_position.value());
EXPECT_EQ(static_cast<std::uint64_t>(0),
cue_track_positions.relative_position.value());
EXPECT_FALSE(cue_track_positions.duration.is_present());
EXPECT_EQ(0, cue_track_positions.duration.value());
EXPECT_EQ(static_cast<std::uint64_t>(0),
cue_track_positions.duration.value());
EXPECT_FALSE(cue_track_positions.block_number.is_present());
EXPECT_EQ(1, cue_track_positions.block_number.value());
EXPECT_EQ(static_cast<std::uint64_t>(1),
cue_track_positions.block_number.value());
}
TEST_F(CueTrackPositionsParserTest, DefaultValues) {
@@ -67,19 +71,23 @@ TEST_F(CueTrackPositionsParserTest, DefaultValues) {
const CueTrackPositions cue_track_positions = parser_.value();
EXPECT_TRUE(cue_track_positions.track.is_present());
EXPECT_EQ(0, cue_track_positions.track.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), cue_track_positions.track.value());
EXPECT_TRUE(cue_track_positions.cluster_position.is_present());
EXPECT_EQ(0, cue_track_positions.cluster_position.value());
EXPECT_EQ(static_cast<std::uint64_t>(0),
cue_track_positions.cluster_position.value());
EXPECT_TRUE(cue_track_positions.relative_position.is_present());
EXPECT_EQ(0, cue_track_positions.relative_position.value());
EXPECT_EQ(static_cast<std::uint64_t>(0),
cue_track_positions.relative_position.value());
EXPECT_TRUE(cue_track_positions.duration.is_present());
EXPECT_EQ(0, cue_track_positions.duration.value());
EXPECT_EQ(static_cast<std::uint64_t>(0),
cue_track_positions.duration.value());
EXPECT_TRUE(cue_track_positions.block_number.is_present());
EXPECT_EQ(1, cue_track_positions.block_number.value());
EXPECT_EQ(static_cast<std::uint64_t>(1),
cue_track_positions.block_number.value());
}
TEST_F(CueTrackPositionsParserTest, CustomValues) {
@@ -110,19 +118,23 @@ TEST_F(CueTrackPositionsParserTest, CustomValues) {
const CueTrackPositions cue_track_positions = parser_.value();
EXPECT_TRUE(cue_track_positions.track.is_present());
EXPECT_EQ(1, cue_track_positions.track.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), cue_track_positions.track.value());
EXPECT_TRUE(cue_track_positions.cluster_position.is_present());
EXPECT_EQ(2, cue_track_positions.cluster_position.value());
EXPECT_EQ(static_cast<std::uint64_t>(2),
cue_track_positions.cluster_position.value());
EXPECT_TRUE(cue_track_positions.relative_position.is_present());
EXPECT_EQ(3, cue_track_positions.relative_position.value());
EXPECT_EQ(static_cast<std::uint64_t>(3),
cue_track_positions.relative_position.value());
EXPECT_TRUE(cue_track_positions.duration.is_present());
EXPECT_EQ(4, cue_track_positions.duration.value());
EXPECT_EQ(static_cast<std::uint64_t>(4),
cue_track_positions.duration.value());
EXPECT_TRUE(cue_track_positions.block_number.is_present());
EXPECT_EQ(5, cue_track_positions.block_number.value());
EXPECT_EQ(static_cast<std::uint64_t>(5),
cue_track_positions.block_number.value());
}
} // namespace

2
webm_parser/tests/date_parser_test.cc
View File

@@ -49,7 +49,7 @@ TEST_F(DateParserTest, IncrementalParse) {
IncrementalParseAndVerify();
EXPECT_EQ(0xFEDCBA9876543210, parser_.value());
EXPECT_EQ(static_cast<std::int64_t>(0xFEDCBA9876543210), parser_.value());
}
} // namespace

12
webm_parser/tests/int_parser_test.cc
View File

@@ -32,24 +32,24 @@ TEST_F(UnsignedIntParserTest, UnsignedCustomDefault) {
ParseAndVerify();
EXPECT_EQ(1, parser_.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), parser_.value());
}
TEST_F(UnsignedIntParserTest, UnsignedValidInt) {
ParseAndVerify();
EXPECT_EQ(0, parser_.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), parser_.value());
SetReaderData({0x01, 0x02, 0x03});
ParseAndVerify();
EXPECT_EQ(0x010203, parser_.value());
EXPECT_EQ(static_cast<std::uint64_t>(0x010203), parser_.value());
SetReaderData({0xFF, 0xFF, 0xFF, 0xFF, 0xFF});
ParseAndVerify();
EXPECT_EQ(0xFFFFFFFFFF, parser_.value());
EXPECT_EQ(static_cast<std::uint64_t>(0xFFFFFFFFFF), parser_.value());
SetReaderData({0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0});
ParseAndVerify();
EXPECT_EQ(0x123456789ABCDEF0, parser_.value());
EXPECT_EQ(static_cast<std::uint64_t>(0x123456789ABCDEF0), parser_.value());
}
TEST_F(UnsignedIntParserTest, UnsignedIncrementalParse) {
@@ -57,7 +57,7 @@ TEST_F(UnsignedIntParserTest, UnsignedIncrementalParse) {
IncrementalParseAndVerify();
EXPECT_EQ(0xFEDCBA9876543210, parser_.value());
EXPECT_EQ(static_cast<std::uint64_t>(0xFEDCBA9876543210), parser_.value());
}
class SignedIntParserTest : public ElementParserTest<SignedIntParser> {};

32
webm_parser/tests/istream_reader_test.cc
View File

@@ -41,11 +41,11 @@ TEST_F(IstreamReaderTest, Read) {
status = reader.Read(5, buffer.data(), &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(5, count);
EXPECT_EQ(static_cast<std::uint64_t>(5), count);
status = reader.Read(10, buffer.data() + 5, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(5, count);
EXPECT_EQ(static_cast<std::uint64_t>(5), count);
std::array<std::uint8_t, 15> expected =
ArrayFromString("abcdefghij\0\0\0\0\0");
@@ -53,7 +53,7 @@ TEST_F(IstreamReaderTest, Read) {
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(Status::kEndOfFile, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(static_cast<std::uint64_t>(0), count);
}
TEST_F(IstreamReaderTest, Skip) {
@@ -65,15 +65,15 @@ TEST_F(IstreamReaderTest, Skip) {
status = reader.Skip(3, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(3, count);
EXPECT_EQ(static_cast<std::uint64_t>(3), count);
status = reader.Skip(10, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(7, count);
EXPECT_EQ(static_cast<std::uint64_t>(7), count);
status = reader.Skip(1, &count);
EXPECT_EQ(Status::kEndOfFile, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(static_cast<std::uint64_t>(0), count);
}
TEST_F(IstreamReaderTest, ReadAndSkip) {
@@ -86,15 +86,15 @@ TEST_F(IstreamReaderTest, ReadAndSkip) {
status = reader.Read(5, buffer.data(), &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(5, count);
EXPECT_EQ(static_cast<std::uint64_t>(5), count);
status = reader.Skip(3, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(3, count);
EXPECT_EQ(static_cast<std::uint64_t>(3), count);
status = reader.Read(5, buffer.data() + 5, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
std::array<std::uint8_t, 10> expected = ArrayFromString("AaBbCEe\0\0\0");
EXPECT_EQ(expected, buffer);
@@ -107,22 +107,22 @@ TEST_F(IstreamReaderTest, Position) {
IstreamReader reader =
IstreamReader::Emplace<std::istringstream>("AaBbCcDdEe");
EXPECT_EQ(0, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(0), reader.Position());
status = reader.Read(5, buffer.data(), &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(5, count);
EXPECT_EQ(5, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(5), count);
EXPECT_EQ(static_cast<std::uint64_t>(5), reader.Position());
status = reader.Skip(3, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(3, count);
EXPECT_EQ(8, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(3), count);
EXPECT_EQ(static_cast<std::uint64_t>(8), reader.Position());
status = reader.Read(5, buffer.data() + 5, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(10, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
EXPECT_EQ(static_cast<std::uint64_t>(10), reader.Position());
std::array<std::uint8_t, 10> expected = ArrayFromString("AaBbCEe\0\0\0");
EXPECT_EQ(expected, buffer);

63
webm_parser/tests/limited_reader_test.cc
View File

@@ -34,7 +34,7 @@ TEST_F(LimitedReaderTest, UnlimitedRead) {
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(4, count);
EXPECT_EQ(static_cast<std::uint64_t>(4), count);
std::array<std::uint8_t, 4> expected_buffer = {{1, 2, 3, 4}};
EXPECT_EQ(expected_buffer, buffer);
@@ -47,7 +47,7 @@ TEST_F(LimitedReaderTest, UnlimitedSkip) {
status = reader.Skip(4, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(4, count);
EXPECT_EQ(static_cast<std::uint64_t>(4), count);
}
TEST_F(LimitedReaderTest, Position) {
@@ -56,16 +56,16 @@ TEST_F(LimitedReaderTest, Position) {
std::uint64_t count;
Status status;
EXPECT_EQ(0, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(0), reader.Position());
status = reader.Read(2, buffer.data(), &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
status = reader.Skip(2, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(4, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
EXPECT_EQ(static_cast<std::uint64_t>(4), reader.Position());
std::array<std::uint8_t, 4> expected_buffer = {{1, 2, 0, 0}};
EXPECT_EQ(expected_buffer, buffer);
@@ -80,16 +80,16 @@ TEST_F(LimitedReaderTest, LimitIndividualRead) {
reader.set_single_read_limit(1);
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(1, count);
EXPECT_EQ(static_cast<std::uint64_t>(1), count);
status = reader.Read(buffer.size() + 1, buffer.data() + 1, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(1, count);
EXPECT_EQ(static_cast<std::uint64_t>(1), count);
reader.set_single_read_limit(2);
status = reader.Read(buffer.size() - 2, buffer.data() + 2, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
std::array<std::uint8_t, 4> expected_buffer = {{1, 2, 3, 4}};
EXPECT_EQ(expected_buffer, buffer);
@@ -103,16 +103,16 @@ TEST_F(LimitedReaderTest, LimitIndividualSkip) {
reader.set_single_skip_limit(1);
status = reader.Skip(4, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(1, count);
EXPECT_EQ(static_cast<std::uint64_t>(1), count);
status = reader.Skip(3, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(1, count);
EXPECT_EQ(static_cast<std::uint64_t>(1), count);
reader.set_single_skip_limit(2);
status = reader.Skip(2, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
}
TEST_F(LimitedReaderTest, LimitRepeatedRead) {
@@ -124,21 +124,21 @@ TEST_F(LimitedReaderTest, LimitRepeatedRead) {
reader.set_total_read_limit(1);
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(1, count);
EXPECT_EQ(static_cast<std::uint64_t>(1), count);
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(Status::kWouldBlock, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(static_cast<std::uint64_t>(0), count);
reader.set_total_read_limit(2);
status = reader.Read(buffer.size() - 1, buffer.data() + 1, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
reader.set_total_read_limit(1);
status = reader.Read(buffer.size() - 3, buffer.data() + 3, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(1, count);
EXPECT_EQ(static_cast<std::uint64_t>(1), count);
std::array<std::uint8_t, 4> expected_buffer = {{1, 2, 3, 4}};
EXPECT_EQ(expected_buffer, buffer);
@@ -152,21 +152,21 @@ TEST_F(LimitedReaderTest, LimitRepeatedSkip) {
reader.set_total_skip_limit(1);
status = reader.Skip(4, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(1, count);
EXPECT_EQ(static_cast<std::uint64_t>(1), count);
status = reader.Skip(4, &count);
EXPECT_EQ(Status::kWouldBlock, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(static_cast<std::uint64_t>(0), count);
reader.set_total_skip_limit(2);
status = reader.Skip(3, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
reader.set_total_skip_limit(1);
status = reader.Skip(1, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(1, count);
EXPECT_EQ(static_cast<std::uint64_t>(1), count);
}
TEST_F(LimitedReaderTest, LimitReadsAndSkips) {
@@ -178,21 +178,21 @@ TEST_F(LimitedReaderTest, LimitReadsAndSkips) {
reader.set_total_read_skip_limit(1);
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(1, count);
EXPECT_EQ(static_cast<std::uint64_t>(1), count);
status = reader.Skip(buffer.size(), &count);
EXPECT_EQ(Status::kWouldBlock, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(static_cast<std::uint64_t>(0), count);
reader.set_total_read_skip_limit(2);
status = reader.Skip(buffer.size() - 1, &count);
EXPECT_EQ(Status::kOkPartial, status.code);
EXPECT_EQ(2, count);
EXPECT_EQ(static_cast<std::uint64_t>(2), count);
reader.set_total_read_skip_limit(1);
status = reader.Read(buffer.size() - 3, buffer.data() + 3, &count);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(1, count);
EXPECT_EQ(static_cast<std::uint64_t>(1), count);
std::array<std::uint8_t, 4> expected = {{1, 0, 0, 4}};
EXPECT_EQ(expected, buffer);
@@ -204,43 +204,44 @@ TEST_F(LimitedReaderTest, CustomStatusWhenBlocked) {
std::uint64_t count;
Status status;
Status expected_status = Status(-123);
const std::uint64_t kZeroCount = 0;
reader.set_single_read_limit(0);
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(Status::kWouldBlock, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(kZeroCount, count);
reader.set_return_status_when_blocked(expected_status);
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(expected_status.code, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(kZeroCount, count);
reader.set_single_read_limit(std::numeric_limits<std::size_t>::max());
reader.set_total_read_limit(0);
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(expected_status.code, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(kZeroCount, count);
reader.set_total_read_limit(std::numeric_limits<std::size_t>::max());
reader.set_single_skip_limit(0);
status = reader.Skip(buffer.size(), &count);
EXPECT_EQ(expected_status.code, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(kZeroCount, count);
reader.set_single_skip_limit(std::numeric_limits<std::uint64_t>::max());
reader.set_total_skip_limit(0);
status = reader.Skip(buffer.size(), &count);
EXPECT_EQ(expected_status.code, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(kZeroCount, count);
reader.set_total_skip_limit(std::numeric_limits<std::uint64_t>::max());
reader.set_total_read_skip_limit(0);
status = reader.Read(buffer.size(), buffer.data(), &count);
EXPECT_EQ(expected_status.code, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(kZeroCount, count);
status = reader.Skip(buffer.size(), &count);
EXPECT_EQ(expected_status.code, status.code);
EXPECT_EQ(0, count);
EXPECT_EQ(kZeroCount, count);
std::array<std::uint8_t, 4> expected_buffer = {{0, 0, 0, 0}};
EXPECT_EQ(expected_buffer, buffer);

2
webm_parser/tests/master_parser_test.cc
View File

@@ -216,7 +216,7 @@ TEST_F(MasterParserTest, UnknownSize) {
ParseAndVerify(kUnknownElementSize);
EXPECT_EQ(5, reader_.Position());
EXPECT_EQ(static_cast<std::uint64_t>(5), reader_.Position());
}
// Consecutive elements with unknown size should parse without issues, despite

16
webm_parser/tests/parser_utils_test.cc
View File

@@ -73,28 +73,28 @@ TEST_F(ParserUtilsTest, AccumulateIntegerBytes) {
status =
AccumulateIntegerBytes(4, &reader, &integer, &num_bytes_actually_read);
EXPECT_EQ(Status::kWouldBlock, status.code);
EXPECT_EQ(1, num_bytes_actually_read);
EXPECT_EQ(0x12, integer);
EXPECT_EQ(static_cast<std::uint64_t>(1), num_bytes_actually_read);
EXPECT_EQ(static_cast<std::uint32_t>(0x12), integer);
reader.set_total_read_limit(std::numeric_limits<std::size_t>::max());
status =
AccumulateIntegerBytes(3, &reader, &integer, &num_bytes_actually_read);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(3, num_bytes_actually_read);
EXPECT_EQ(0x12345678, integer);
EXPECT_EQ(static_cast<std::uint64_t>(3), num_bytes_actually_read);
EXPECT_EQ(static_cast<std::uint32_t>(0x12345678), integer);
// Make sure calling with num_bytes_remaining == 0 is a no-op.
status =
AccumulateIntegerBytes(0, &reader, &integer, &num_bytes_actually_read);
EXPECT_EQ(Status::kOkCompleted, status.code);
EXPECT_EQ(0, num_bytes_actually_read);
EXPECT_EQ(0x12345678, integer);
EXPECT_EQ(static_cast<std::uint64_t>(0), num_bytes_actually_read);
EXPECT_EQ(static_cast<std::uint32_t>(0x12345678), integer);
status =
AccumulateIntegerBytes(4, &reader, &integer, &num_bytes_actually_read);
EXPECT_EQ(Status::kEndOfFile, status.code);
EXPECT_EQ(0, num_bytes_actually_read);
EXPECT_EQ(0x12345678, integer);
EXPECT_EQ(static_cast<std::uint64_t>(0), num_bytes_actually_read);
EXPECT_EQ(static_cast<std::uint32_t>(0x12345678), integer);
}
} // namespace

6
webm_parser/tests/recursive_parser_test.cc
View File

@@ -32,12 +32,12 @@ class FailParser : public ElementParser {
public:
FailParser() { EXPECT_FALSE(true); }
Status Init(const ElementMetadata& metadata,
std::uint64_t max_size) override {
Status Init(const ElementMetadata& /* metadata */,
std::uint64_t /* max_size */) override {
return Status(Status::kInvalidElementSize);
}
Status Feed(Callback* callback, Reader* reader,
Status Feed(Callback* /* callback */, Reader* /* reader */,
std::uint64_t* num_bytes_read) override {
*num_bytes_read = 0;
return Status(Status::kInvalidElementSize);

6
webm_parser/tests/simple_tag_parser_test.cc
View File

@@ -44,7 +44,7 @@ TEST_F(SimpleTagParserTest, DefaultParse) {
EXPECT_FALSE(simple_tag.binary.is_present());
EXPECT_EQ(std::vector<std::uint8_t>{}, simple_tag.binary.value());
EXPECT_EQ(0, simple_tag.tags.size());
EXPECT_EQ(static_cast<std::size_t>(0), simple_tag.tags.size());
}
TEST_F(SimpleTagParserTest, DefaultValues) {
@@ -87,7 +87,7 @@ TEST_F(SimpleTagParserTest, DefaultValues) {
EXPECT_TRUE(simple_tag.binary.is_present());
EXPECT_EQ(std::vector<std::uint8_t>{}, simple_tag.binary.value());
ASSERT_EQ(1, simple_tag.tags.size());
ASSERT_EQ(static_cast<std::size_t>(1), simple_tag.tags.size());
EXPECT_TRUE(simple_tag.tags[0].is_present());
EXPECT_EQ(SimpleTag{}, simple_tag.tags[0].value());
}
@@ -176,7 +176,7 @@ TEST_F(SimpleTagParserTest, CustomValues) {
temp.string.Set("g", true);
expected.tags.emplace_back(temp, true);
ASSERT_EQ(1, simple_tag.tags.size());
ASSERT_EQ(static_cast<std::size_t>(1), simple_tag.tags.size());
EXPECT_TRUE(simple_tag.tags[0].is_present());
EXPECT_EQ(expected, simple_tag.tags[0].value());
}

10
webm_parser/tests/size_parser_test.cc
View File

@@ -33,29 +33,29 @@ TEST_F(SizeParserTest, EarlyEndOfFile) {
TEST_F(SizeParserTest, ValidSize) {
SetReaderData({0x80});
ParseAndVerify();
EXPECT_EQ(0, parser_.size());
EXPECT_EQ(static_cast<std::uint64_t>(0), parser_.size());
ResetParser();
SetReaderData({0x01, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE});
ParseAndVerify();
EXPECT_EQ(0x123456789ABCDE, parser_.size());
EXPECT_EQ(static_cast<std::uint64_t>(0x123456789ABCDE), parser_.size());
}
TEST_F(SizeParserTest, UnknownSize) {
SetReaderData({0xFF});
ParseAndVerify();
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, parser_.size());
EXPECT_EQ(static_cast<std::uint64_t>(0xFFFFFFFFFFFFFFFF), parser_.size());
ResetParser();
SetReaderData({0x1F, 0xFF, 0xFF, 0xFF});
ParseAndVerify();
EXPECT_EQ(0xFFFFFFFFFFFFFFFF, parser_.size());
EXPECT_EQ(static_cast<std::uint64_t>(0xFFFFFFFFFFFFFFFF), parser_.size());
}
TEST_F(SizeParserTest, IncrementalParse) {
SetReaderData({0x11, 0x23, 0x45, 0x67});
IncrementalParseAndVerify();
EXPECT_EQ(0x01234567, parser_.size());
EXPECT_EQ(static_cast<std::uint64_t>(0x01234567), parser_.size());
}
} // namespace

6
webm_parser/tests/slices_parser_test.cc
View File

@@ -27,7 +27,7 @@ TEST_F(SlicesParserTest, DefaultParse) {
const Slices slices = parser_.value();
EXPECT_EQ(0, slices.slices.size());
EXPECT_EQ(static_cast<std::size_t>(0), slices.slices.size());
}
TEST_F(SlicesParserTest, DefaultValues) {
@@ -40,7 +40,7 @@ TEST_F(SlicesParserTest, DefaultValues) {
const Slices slices = parser_.value();
ASSERT_EQ(1, slices.slices.size());
ASSERT_EQ(static_cast<std::size_t>(1), slices.slices.size());
EXPECT_TRUE(slices.slices[0].is_present());
EXPECT_EQ(TimeSlice{}, slices.slices[0].value());
}
@@ -68,7 +68,7 @@ TEST_F(SlicesParserTest, CustomValues) {
TimeSlice expected;
ASSERT_EQ(2, slices.slices.size());
ASSERT_EQ(static_cast<std::size_t>(2), slices.slices.size());
expected.lace_number.Set(1, true);
EXPECT_TRUE(slices.slices[0].is_present());
EXPECT_EQ(expected, slices.slices[0].value());

18
webm_parser/tests/targets_parser_test.cc
View File

@@ -28,12 +28,12 @@ TEST_F(TargetsParserTest, DefaultParse) {
const Targets targets = parser_.value();
EXPECT_FALSE(targets.type_value.is_present());
EXPECT_EQ(50, targets.type_value.value());
EXPECT_EQ(static_cast<std::uint64_t>(50), targets.type_value.value());
EXPECT_FALSE(targets.type.is_present());
EXPECT_EQ("", targets.type.value());
EXPECT_EQ(0, targets.track_uids.size());
EXPECT_EQ(static_cast<std::size_t>(0), targets.track_uids.size());
}
TEST_F(TargetsParserTest, DefaultValues) {
@@ -53,14 +53,14 @@ TEST_F(TargetsParserTest, DefaultValues) {
const Targets targets = parser_.value();
EXPECT_TRUE(targets.type_value.is_present());
EXPECT_EQ(50, targets.type_value.value());
EXPECT_EQ(static_cast<std::uint64_t>(50), targets.type_value.value());
EXPECT_TRUE(targets.type.is_present());
EXPECT_EQ("", targets.type.value());
ASSERT_EQ(1, targets.track_uids.size());
ASSERT_EQ(static_cast<std::size_t>(1), targets.track_uids.size());
EXPECT_TRUE(targets.track_uids[0].is_present());
EXPECT_EQ(0, targets.track_uids[0].value());
EXPECT_EQ(static_cast<std::uint64_t>(0), targets.track_uids[0].value());
}
TEST_F(TargetsParserTest, CustomValues) {
@@ -87,16 +87,16 @@ TEST_F(TargetsParserTest, CustomValues) {
const Targets targets = parser_.value();
EXPECT_TRUE(targets.type_value.is_present());
EXPECT_EQ(0, targets.type_value.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), targets.type_value.value());
EXPECT_TRUE(targets.type.is_present());
EXPECT_EQ("Hi", targets.type.value());
ASSERT_EQ(2, targets.track_uids.size());
ASSERT_EQ(static_cast<std::size_t>(2), targets.track_uids.size());
EXPECT_TRUE(targets.track_uids[0].is_present());
EXPECT_EQ(1, targets.track_uids[0].value());
EXPECT_EQ(static_cast<std::uint64_t>(1), targets.track_uids[0].value());
EXPECT_TRUE(targets.track_uids[1].is_present());
EXPECT_EQ(2, targets.track_uids[1].value());
EXPECT_EQ(static_cast<std::uint64_t>(2), targets.track_uids[1].value());
}
} // namespace

6
webm_parser/tests/time_slice_parser_test.cc
View File

@@ -28,7 +28,7 @@ TEST_F(TimeSliceParserTest, DefaultParse) {
const TimeSlice time_slice = parser_.value();
EXPECT_FALSE(time_slice.lace_number.is_present());
EXPECT_EQ(0, time_slice.lace_number.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), time_slice.lace_number.value());
}
TEST_F(TimeSliceParserTest, DefaultValues) {
@@ -42,7 +42,7 @@ TEST_F(TimeSliceParserTest, DefaultValues) {
const TimeSlice time_slice = parser_.value();
EXPECT_TRUE(time_slice.lace_number.is_present());
EXPECT_EQ(0, time_slice.lace_number.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), time_slice.lace_number.value());
}
TEST_F(TimeSliceParserTest, CustomValues) {
@@ -57,7 +57,7 @@ TEST_F(TimeSliceParserTest, CustomValues) {
const TimeSlice time_slice = parser_.value();
EXPECT_TRUE(time_slice.lace_number.is_present());
EXPECT_EQ(1, time_slice.lace_number.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), time_slice.lace_number.value());
}
} // namespace

6
webm_parser/tests/var_int_parser_test.cc
View File

@@ -33,20 +33,20 @@ TEST_F(VarIntParserTest, EarlyEndOfFile) {
TEST_F(VarIntParserTest, ValidValue) {
SetReaderData({0x80});
ParseAndVerify();
EXPECT_EQ(0, parser_.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), parser_.value());
EXPECT_EQ(1, parser_.encoded_length());
ResetParser();
SetReaderData({0x01, 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE});
ParseAndVerify();
EXPECT_EQ(0x123456789ABCDE, parser_.value());
EXPECT_EQ(static_cast<std::uint64_t>(0x123456789ABCDE), parser_.value());
EXPECT_EQ(8, parser_.encoded_length());
}
TEST_F(VarIntParserTest, IncrementalParse) {
SetReaderData({0x11, 0x23, 0x45, 0x67});
IncrementalParseAndVerify();
EXPECT_EQ(0x01234567, parser_.value());
EXPECT_EQ(static_cast<std::uint64_t>(0x01234567), parser_.value());
EXPECT_EQ(4, parser_.encoded_length());
}

91
webm_parser/tests/video_parser_test.cc
View File

@@ -38,25 +38,25 @@ TEST_F(VideoParserTest, DefaultParse) {
EXPECT_EQ(StereoMode::kMono, video.stereo_mode.value());
EXPECT_FALSE(video.alpha_mode.is_present());
EXPECT_EQ(0, video.alpha_mode.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.alpha_mode.value());
EXPECT_FALSE(video.pixel_width.is_present());
EXPECT_EQ(0, video.pixel_width.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_width.value());
EXPECT_FALSE(video.pixel_height.is_present());
EXPECT_EQ(0, video.pixel_height.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_height.value());
EXPECT_FALSE(video.pixel_crop_bottom.is_present());
EXPECT_EQ(0, video.pixel_crop_bottom.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_bottom.value());
EXPECT_FALSE(video.pixel_crop_top.is_present());
EXPECT_EQ(0, video.pixel_crop_top.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_top.value());
EXPECT_FALSE(video.pixel_crop_left.is_present());
EXPECT_EQ(0, video.pixel_crop_left.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_left.value());
EXPECT_FALSE(video.pixel_crop_right.is_present());
EXPECT_EQ(0, video.pixel_crop_right.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_right.value());
EXPECT_FALSE(video.display_width.is_present());
EXPECT_EQ(video.pixel_width.value(), video.display_width.value());
@@ -71,7 +71,7 @@ TEST_F(VideoParserTest, DefaultParse) {
EXPECT_EQ(AspectRatioType::kFreeResizing, video.aspect_ratio_type.value());
EXPECT_FALSE(video.frame_rate.is_present());
EXPECT_EQ(0, video.frame_rate.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.frame_rate.value());
EXPECT_FALSE(video.colour.is_present());
EXPECT_EQ(Colour{}, video.colour.value());
@@ -136,25 +136,25 @@ TEST_F(VideoParserTest, DefaultValues) {
EXPECT_EQ(StereoMode::kMono, video.stereo_mode.value());
EXPECT_TRUE(video.alpha_mode.is_present());
EXPECT_EQ(0, video.alpha_mode.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.alpha_mode.value());
EXPECT_TRUE(video.pixel_width.is_present());
EXPECT_EQ(0, video.pixel_width.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_width.value());
EXPECT_TRUE(video.pixel_height.is_present());
EXPECT_EQ(0, video.pixel_height.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_height.value());
EXPECT_TRUE(video.pixel_crop_bottom.is_present());
EXPECT_EQ(0, video.pixel_crop_bottom.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_bottom.value());
EXPECT_TRUE(video.pixel_crop_top.is_present());
EXPECT_EQ(0, video.pixel_crop_top.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_top.value());
EXPECT_TRUE(video.pixel_crop_left.is_present());
EXPECT_EQ(0, video.pixel_crop_left.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_left.value());
EXPECT_TRUE(video.pixel_crop_right.is_present());
EXPECT_EQ(0, video.pixel_crop_right.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_right.value());
EXPECT_TRUE(video.display_width.is_present());
EXPECT_EQ(video.pixel_width.value(), video.display_width.value());
@@ -252,31 +252,31 @@ TEST_F(VideoParserTest, CustomValues) {
EXPECT_EQ(StereoMode::kTopBottomRightFirst, video.stereo_mode.value());
EXPECT_TRUE(video.alpha_mode.is_present());
EXPECT_EQ(3, video.alpha_mode.value());
EXPECT_EQ(static_cast<std::uint64_t>(3), video.alpha_mode.value());
EXPECT_TRUE(video.pixel_width.is_present());
EXPECT_EQ(4, video.pixel_width.value());
EXPECT_EQ(static_cast<std::uint64_t>(4), video.pixel_width.value());
EXPECT_TRUE(video.pixel_height.is_present());
EXPECT_EQ(5, video.pixel_height.value());
EXPECT_EQ(static_cast<std::uint64_t>(5), video.pixel_height.value());
EXPECT_TRUE(video.pixel_crop_bottom.is_present());
EXPECT_EQ(6, video.pixel_crop_bottom.value());
EXPECT_EQ(static_cast<std::uint64_t>(6), video.pixel_crop_bottom.value());
EXPECT_TRUE(video.pixel_crop_top.is_present());
EXPECT_EQ(7, video.pixel_crop_top.value());
EXPECT_EQ(static_cast<std::uint64_t>(7), video.pixel_crop_top.value());
EXPECT_TRUE(video.pixel_crop_left.is_present());
EXPECT_EQ(8, video.pixel_crop_left.value());
EXPECT_EQ(static_cast<std::uint64_t>(8), video.pixel_crop_left.value());
EXPECT_TRUE(video.pixel_crop_right.is_present());
EXPECT_EQ(9, video.pixel_crop_right.value());
EXPECT_EQ(static_cast<std::uint64_t>(9), video.pixel_crop_right.value());
EXPECT_TRUE(video.display_width.is_present());
EXPECT_EQ(10, video.display_width.value());
EXPECT_EQ(static_cast<std::uint64_t>(10), video.display_width.value());
EXPECT_TRUE(video.display_height.is_present());
EXPECT_EQ(11, video.display_height.value());
EXPECT_EQ(static_cast<std::uint64_t>(11), video.display_height.value());
EXPECT_TRUE(video.display_unit.is_present());
EXPECT_EQ(DisplayUnit::kInches, video.display_unit.value());
@@ -289,7 +289,8 @@ TEST_F(VideoParserTest, CustomValues) {
EXPECT_TRUE(video.colour.is_present());
EXPECT_TRUE(video.colour.value().bits_per_channel.is_present());
EXPECT_EQ(1, video.colour.value().bits_per_channel.value());
EXPECT_EQ(static_cast<std::uint64_t>(1),
video.colour.value().bits_per_channel.value());
}
TEST_F(VideoParserTest, AbsentDisplaySize) {
@@ -314,31 +315,31 @@ TEST_F(VideoParserTest, AbsentDisplaySize) {
EXPECT_EQ(StereoMode::kMono, video.stereo_mode.value());
EXPECT_FALSE(video.alpha_mode.is_present());
EXPECT_EQ(0, video.alpha_mode.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.alpha_mode.value());
EXPECT_TRUE(video.pixel_width.is_present());
EXPECT_EQ(1, video.pixel_width.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), video.pixel_width.value());
EXPECT_TRUE(video.pixel_height.is_present());
EXPECT_EQ(2, video.pixel_height.value());
EXPECT_EQ(static_cast<std::uint64_t>(2), video.pixel_height.value());
EXPECT_FALSE(video.pixel_crop_bottom.is_present());
EXPECT_EQ(0, video.pixel_crop_bottom.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_bottom.value());
EXPECT_FALSE(video.pixel_crop_top.is_present());
EXPECT_EQ(0, video.pixel_crop_top.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_top.value());
EXPECT_FALSE(video.pixel_crop_left.is_present());
EXPECT_EQ(0, video.pixel_crop_left.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_left.value());
EXPECT_FALSE(video.pixel_crop_right.is_present());
EXPECT_EQ(0, video.pixel_crop_right.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_right.value());
EXPECT_FALSE(video.display_width.is_present());
EXPECT_EQ(1, video.display_width.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), video.display_width.value());
EXPECT_FALSE(video.display_height.is_present());
EXPECT_EQ(2, video.display_height.value());
EXPECT_EQ(static_cast<std::uint64_t>(2), video.display_height.value());
EXPECT_FALSE(video.display_unit.is_present());
EXPECT_EQ(DisplayUnit::kPixels, video.display_unit.value());
@@ -347,7 +348,7 @@ TEST_F(VideoParserTest, AbsentDisplaySize) {
EXPECT_EQ(AspectRatioType::kFreeResizing, video.aspect_ratio_type.value());
EXPECT_FALSE(video.frame_rate.is_present());
EXPECT_EQ(0, video.frame_rate.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.frame_rate.value());
EXPECT_FALSE(video.colour.is_present());
EXPECT_EQ(Colour{}, video.colour.value());
@@ -381,31 +382,31 @@ TEST_F(VideoParserTest, DefaultDisplaySize) {
EXPECT_EQ(StereoMode::kMono, video.stereo_mode.value());
EXPECT_FALSE(video.alpha_mode.is_present());
EXPECT_EQ(0, video.alpha_mode.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.alpha_mode.value());
EXPECT_TRUE(video.pixel_width.is_present());
EXPECT_EQ(1, video.pixel_width.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), video.pixel_width.value());
EXPECT_TRUE(video.pixel_height.is_present());
EXPECT_EQ(2, video.pixel_height.value());
EXPECT_EQ(static_cast<std::uint64_t>(2), video.pixel_height.value());
EXPECT_FALSE(video.pixel_crop_bottom.is_present());
EXPECT_EQ(0, video.pixel_crop_bottom.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_bottom.value());
EXPECT_FALSE(video.pixel_crop_top.is_present());
EXPECT_EQ(0, video.pixel_crop_top.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_top.value());
EXPECT_FALSE(video.pixel_crop_left.is_present());
EXPECT_EQ(0, video.pixel_crop_left.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_left.value());
EXPECT_FALSE(video.pixel_crop_right.is_present());
EXPECT_EQ(0, video.pixel_crop_right.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.pixel_crop_right.value());
EXPECT_TRUE(video.display_width.is_present());
EXPECT_EQ(1, video.display_width.value());
EXPECT_EQ(static_cast<std::uint64_t>(1), video.display_width.value());
EXPECT_TRUE(video.display_height.is_present());
EXPECT_EQ(2, video.display_height.value());
EXPECT_EQ(static_cast<std::uint64_t>(2), video.display_height.value());
EXPECT_FALSE(video.display_unit.is_present());
EXPECT_EQ(DisplayUnit::kPixels, video.display_unit.value());
@@ -414,7 +415,7 @@ TEST_F(VideoParserTest, DefaultDisplaySize) {
EXPECT_EQ(AspectRatioType::kFreeResizing, video.aspect_ratio_type.value());
EXPECT_FALSE(video.frame_rate.is_present());
EXPECT_EQ(0, video.frame_rate.value());
EXPECT_EQ(static_cast<std::uint64_t>(0), video.frame_rate.value());
EXPECT_FALSE(video.colour.is_present());
EXPECT_EQ(Colour{}, video.colour.value());

4
webm_parser/tests/virtual_block_parser_test.cc
View File

@@ -52,7 +52,7 @@ TEST_F(VirtualBlockParserTest, ValidBlock) {
const VirtualBlock virtual_block = parser_.value();
EXPECT_EQ(1, virtual_block.track_number);
EXPECT_EQ(static_cast<std::uint64_t>(1), virtual_block.track_number);
EXPECT_EQ(0x1234, virtual_block.timecode);
}
@@ -67,7 +67,7 @@ TEST_F(VirtualBlockParserTest, IncrementalParse) {
const VirtualBlock virtual_block = parser_.value();
EXPECT_EQ(2, virtual_block.track_number);
EXPECT_EQ(static_cast<std::uint64_t>(2), virtual_block.track_number);
EXPECT_EQ(-2, virtual_block.timecode);
}

4
webm_parser/tests/webm_parser_test.cc
View File

@@ -237,7 +237,7 @@ TEST_F(WebmParserTest, SwapAfterFailedParse) {
WebmParser parser1;
Status status = parser1.Feed(&expect_nothing, &reader);
EXPECT_EQ(Status::kInvalidElementId, status.code);
EXPECT_EQ(1, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(1), reader.Position());
// After swapping, the parser should retain its failed state and not consume
// more data.
@@ -245,7 +245,7 @@ TEST_F(WebmParserTest, SwapAfterFailedParse) {
parser2.Swap(&parser1);
status = parser2.Feed(&expect_nothing, &reader);
EXPECT_EQ(Status::kInvalidElementId, status.code);
EXPECT_EQ(1, reader.Position());
EXPECT_EQ(static_cast<std::uint64_t>(1), reader.Position());
// parser1 should be a fresh/new parser after the swap, so parsing should
// succeed.