diff --git a/webm_parser/demo/demo.cc b/webm_parser/demo/demo.cc
index c62bd45..d00adc3 100644
--- a/webm_parser/demo/demo.cc
+++ b/webm_parser/demo/demo.cc
@@ -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);
   }
 };
diff --git a/webm_parser/src/block_parser.cc b/webm_parser/src/block_parser.cc
index 54df164..86981e4 100644
--- a/webm_parser/src/block_parser.cc
+++ b/webm_parser/src/block_parser.cc
@@ -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,
diff --git a/webm_parser/src/callback.cc b/webm_parser/src/callback.cc
index 1a72161..cda30c8 100644
--- a/webm_parser/src/callback.cc
+++ b/webm_parser/src/callback.cc
@@ -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);
 }
 
diff --git a/webm_parser/src/element_parser.h b/webm_parser/src/element_parser.h
index b2381d7..5e202e8 100644
--- a/webm_parser/src/element_parser.h
+++ b/webm_parser/src/element_parser.h
@@ -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);
   }
 
diff --git a/webm_parser/src/istream_reader.cc b/webm_parser/src/istream_reader.cc
index 6405d6f..6993fc0 100644
--- a/webm_parser/src/istream_reader.cc
+++ b/webm_parser/src/istream_reader.cc
@@ -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);
diff --git a/webm_parser/src/master_value_parser.h b/webm_parser/src/master_value_parser.h
index 3552a81..8b39c8c 100644
--- a/webm_parser/src/master_value_parser.h
+++ b/webm_parser/src/master_value_parser.h
@@ -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_;
diff --git a/webm_parser/src/parser_utils.h b/webm_parser/src/parser_utils.h
index 1287916..becb1c7 100644
--- a/webm_parser/src/parser_utils.h
+++ b/webm_parser/src/parser_utils.h
@@ -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);
   }
 
diff --git a/webm_parser/src/skip_callback.h b/webm_parser/src/skip_callback.h
index 2a126b9..e1c28e5 100644
--- a/webm_parser/src/skip_callback.h
+++ b/webm_parser/src/skip_callback.h
@@ -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);
   }
diff --git a/webm_parser/test_utils/element_parser_test.h b/webm_parser/test_utils/element_parser_test.h
index 08df594..d0a6530 100644
--- a/webm_parser/test_utils/element_parser_test.h
+++ b/webm_parser/test_utils/element_parser_test.h
@@ -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);
 
diff --git a/webm_parser/test_utils/parser_test.h b/webm_parser/test_utils/parser_test.h
index a7634b0..73399cd 100644
--- a/webm_parser/test_utils/parser_test.h
+++ b/webm_parser/test_utils/parser_test.h
@@ -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);
 
diff --git a/webm_parser/tests/audio_parser_test.cc b/webm_parser/tests/audio_parser_test.cc
index ea07b72..3a609b0 100644
--- a/webm_parser/tests/audio_parser_test.cc
+++ b/webm_parser/tests/audio_parser_test.cc
@@ -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
diff --git a/webm_parser/tests/block_additions_parser_test.cc b/webm_parser/tests/block_additions_parser_test.cc
index d080085..290b3f5 100644
--- a/webm_parser/tests/block_additions_parser_test.cc
+++ b/webm_parser/tests/block_additions_parser_test.cc
@@ -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());
diff --git a/webm_parser/tests/block_header_parser_test.cc b/webm_parser/tests/block_header_parser_test.cc
index 9c23e1f..3f06dc3 100644
--- a/webm_parser/tests/block_header_parser_test.cc
+++ b/webm_parser/tests/block_header_parser_test.cc
@@ -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);
 }
diff --git a/webm_parser/tests/block_more_parser_test.cc b/webm_parser/tests/block_more_parser_test.cc
index 5bf66f8..41c892c 100644
--- a/webm_parser/tests/block_more_parser_test.cc
+++ b/webm_parser/tests/block_more_parser_test.cc
@@ -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());
diff --git a/webm_parser/tests/block_parser_test.cc b/webm_parser/tests/block_parser_test.cc
index d1d5461..bdb58b5 100644
--- a/webm_parser/tests/block_parser_test.cc
+++ b/webm_parser/tests/block_parser_test.cc
@@ -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;
diff --git a/webm_parser/tests/buffer_reader_test.cc b/webm_parser/tests/buffer_reader_test.cc
index 07246d6..57f9d3d 100644
--- a/webm_parser/tests/buffer_reader_test.cc
+++ b/webm_parser/tests/buffer_reader_test.cc
@@ -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);
diff --git a/webm_parser/tests/callback_test.cc b/webm_parser/tests/callback_test.cc
index e079167..e8aa974 100644
--- a/webm_parser/tests/callback_test.cc
+++ b/webm_parser/tests/callback_test.cc
@@ -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 {};
diff --git a/webm_parser/tests/chapter_atom_parser_test.cc b/webm_parser/tests/chapter_atom_parser_test.cc
index 7a30c45..10c656a 100644
--- a/webm_parser/tests/chapter_atom_parser_test.cc
+++ b/webm_parser/tests/chapter_atom_parser_test.cc
@@ -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());
 }
diff --git a/webm_parser/tests/chapter_display_parser_test.cc b/webm_parser/tests/chapter_display_parser_test.cc
index bf8b826..224c1da 100644
--- a/webm_parser/tests/chapter_display_parser_test.cc
+++ b/webm_parser/tests/chapter_display_parser_test.cc
@@ -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());
diff --git a/webm_parser/tests/colour_parser_test.cc b/webm_parser/tests/colour_parser_test.cc
index 625d5a9..0fe31f0 100644
--- a/webm_parser/tests/colour_parser_test.cc
+++ b/webm_parser/tests/colour_parser_test.cc
@@ -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);
diff --git a/webm_parser/tests/content_encoding_parser_test.cc b/webm_parser/tests/content_encoding_parser_test.cc
index 5553171..c739f50 100644
--- a/webm_parser/tests/content_encoding_parser_test.cc
+++ b/webm_parser/tests/content_encoding_parser_test.cc
@@ -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());
diff --git a/webm_parser/tests/content_encodings_parser_test.cc b/webm_parser/tests/content_encodings_parser_test.cc
index cb8d8f3..fedb6aa 100644
--- a/webm_parser/tests/content_encodings_parser_test.cc
+++ b/webm_parser/tests/content_encodings_parser_test.cc
@@ -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());
diff --git a/webm_parser/tests/cue_track_positions_parser_test.cc b/webm_parser/tests/cue_track_positions_parser_test.cc
index 9122bef..d7b6844 100644
--- a/webm_parser/tests/cue_track_positions_parser_test.cc
+++ b/webm_parser/tests/cue_track_positions_parser_test.cc
@@ -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
diff --git a/webm_parser/tests/date_parser_test.cc b/webm_parser/tests/date_parser_test.cc
index 7ce50e0..e81f452 100644
--- a/webm_parser/tests/date_parser_test.cc
+++ b/webm_parser/tests/date_parser_test.cc
@@ -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
diff --git a/webm_parser/tests/int_parser_test.cc b/webm_parser/tests/int_parser_test.cc
index 0b1388e..c2e74e2 100644
--- a/webm_parser/tests/int_parser_test.cc
+++ b/webm_parser/tests/int_parser_test.cc
@@ -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> {};
diff --git a/webm_parser/tests/istream_reader_test.cc b/webm_parser/tests/istream_reader_test.cc
index 35b1a01..561e748 100644
--- a/webm_parser/tests/istream_reader_test.cc
+++ b/webm_parser/tests/istream_reader_test.cc
@@ -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);
diff --git a/webm_parser/tests/limited_reader_test.cc b/webm_parser/tests/limited_reader_test.cc
index 95c1b8f..9064a45 100644
--- a/webm_parser/tests/limited_reader_test.cc
+++ b/webm_parser/tests/limited_reader_test.cc
@@ -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);
diff --git a/webm_parser/tests/master_parser_test.cc b/webm_parser/tests/master_parser_test.cc
index 7a2995d..84edb27 100644
--- a/webm_parser/tests/master_parser_test.cc
+++ b/webm_parser/tests/master_parser_test.cc
@@ -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
diff --git a/webm_parser/tests/parser_utils_test.cc b/webm_parser/tests/parser_utils_test.cc
index d199212..69d3679 100644
--- a/webm_parser/tests/parser_utils_test.cc
+++ b/webm_parser/tests/parser_utils_test.cc
@@ -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
diff --git a/webm_parser/tests/recursive_parser_test.cc b/webm_parser/tests/recursive_parser_test.cc
index 18343c6..88af177 100644
--- a/webm_parser/tests/recursive_parser_test.cc
+++ b/webm_parser/tests/recursive_parser_test.cc
@@ -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);
diff --git a/webm_parser/tests/simple_tag_parser_test.cc b/webm_parser/tests/simple_tag_parser_test.cc
index e51bb32..27931ec 100644
--- a/webm_parser/tests/simple_tag_parser_test.cc
+++ b/webm_parser/tests/simple_tag_parser_test.cc
@@ -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());
 }
diff --git a/webm_parser/tests/size_parser_test.cc b/webm_parser/tests/size_parser_test.cc
index da1b939..2cb7f53 100644
--- a/webm_parser/tests/size_parser_test.cc
+++ b/webm_parser/tests/size_parser_test.cc
@@ -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
diff --git a/webm_parser/tests/slices_parser_test.cc b/webm_parser/tests/slices_parser_test.cc
index 0d3a2e5..44abba6 100644
--- a/webm_parser/tests/slices_parser_test.cc
+++ b/webm_parser/tests/slices_parser_test.cc
@@ -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());
diff --git a/webm_parser/tests/targets_parser_test.cc b/webm_parser/tests/targets_parser_test.cc
index 66de164..d424ecf 100644
--- a/webm_parser/tests/targets_parser_test.cc
+++ b/webm_parser/tests/targets_parser_test.cc
@@ -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
diff --git a/webm_parser/tests/time_slice_parser_test.cc b/webm_parser/tests/time_slice_parser_test.cc
index c008d1e..e9bd145 100644
--- a/webm_parser/tests/time_slice_parser_test.cc
+++ b/webm_parser/tests/time_slice_parser_test.cc
@@ -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
diff --git a/webm_parser/tests/var_int_parser_test.cc b/webm_parser/tests/var_int_parser_test.cc
index 48e987b..50e5915 100644
--- a/webm_parser/tests/var_int_parser_test.cc
+++ b/webm_parser/tests/var_int_parser_test.cc
@@ -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());
 }
 
diff --git a/webm_parser/tests/video_parser_test.cc b/webm_parser/tests/video_parser_test.cc
index 0c7cce8..28a676f 100644
--- a/webm_parser/tests/video_parser_test.cc
+++ b/webm_parser/tests/video_parser_test.cc
@@ -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());
diff --git a/webm_parser/tests/virtual_block_parser_test.cc b/webm_parser/tests/virtual_block_parser_test.cc
index b89cd35..97ef741 100644
--- a/webm_parser/tests/virtual_block_parser_test.cc
+++ b/webm_parser/tests/virtual_block_parser_test.cc
@@ -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);
 }
 
diff --git a/webm_parser/tests/webm_parser_test.cc b/webm_parser/tests/webm_parser_test.cc
index 25e2f36..5e15774 100644
--- a/webm_parser/tests/webm_parser_test.cc
+++ b/webm_parser/tests/webm_parser_test.cc
@@ -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.