fix(build): Compile found by macOS15 intel compiler

Several issues were found in test programs:
- Not directly comparable enums
- Ambiguous function calls involving derived function overridden implementation
- Incorrectly implemented derived function that don’t use const or override correctly
I expect newer compiler to pick up on these eventually so let’s fix them now.
These are test fixes and don’t affect engine code.

Author: czentgr

velox/dwio/dwrf/test/ColumnWriterTest.cpp

@@ -65,10 +65,10 @@ class MockStreamInformation : public StreamInformation {
     return streamIdentifier_.encodingKey().sequence();
   }
 
-  MOCK_CONST_METHOD0(getOffset, uint64_t());
-  MOCK_CONST_METHOD0(getLength, uint64_t());
-  MOCK_CONST_METHOD0(getUseVInts, bool());
-  MOCK_CONST_METHOD0(valid, bool());
+  MOCK_METHOD(uint64_t, getOffset, (), (const, override));
+  MOCK_METHOD(uint64_t, getLength, (), (const, override));
+  MOCK_METHOD(bool, getUseVInts, (), (const, override));
+  MOCK_METHOD(bool, valid, (), (const, override));
 
  private:
   const DwrfStreamIdentifier& streamIdentifier_;

velox/dwio/dwrf/test/OrcTest.h

@@ -100,16 +100,20 @@ class MockStripeStreams : public StripeStreams {
   MOCK_METHOD2(
       genMockDictDataSetter,
       std::function<void(BufferPtr&, MemoryPool*)>(uint32_t, uint32_t));
-  MOCK_METHOD0(
+  MOCK_METHOD(
+      std::shared_ptr<StripeDictionaryCache>,
       getStripeDictionaryCache,
-      std::shared_ptr<StripeDictionaryCache>());
+      (),
+      (override));
   MOCK_CONST_METHOD1(getEncodingProxy, proto::ColumnEncoding*(uint64_t));
   MOCK_CONST_METHOD1(
       getEncodingOrcProxy,
       proto::orc::ColumnEncoding*(uint64_t));
-  MOCK_CONST_METHOD2(
+  MOCK_METHOD(
+      uint32_t,
       visitStreamsOfNode,
-      uint32_t(uint32_t, std::function<void(const StreamInformation&)>));
+      (uint32_t, std::function<void(const StreamInformation&)>),
+      (const, override));
   MOCK_CONST_METHOD3(
       getStreamProxy,
       dwio::common::SeekableInputStream*(uint32_t, proto::Stream_Kind, bool));

velox/dwio/dwrf/test/TestStripeStream.cpp

@@ -840,9 +840,11 @@ class TestStripeStreams : public StripeStreamsBase {
   MOCK_CONST_METHOD2(
       getEncodingOrcProxy,
       proto::orc::ColumnEncoding*(uint32_t, uint32_t));
-  MOCK_CONST_METHOD2(
+  MOCK_METHOD(
+      uint32_t,
       visitStreamsOfNode,
-      uint32_t(uint32_t, std::function<void(const StreamInformation&)>));
+      (uint32_t, std::function<void(const StreamInformation&)>),
+      (const, override));
   MOCK_CONST_METHOD4(
       getStreamProxy,
       SeekableInputStream*(uint32_t, uint32_t, proto::Stream_Kind, bool));

velox/dwio/dwrf/test/WriterFlushTest.cpp

@@ -173,11 +173,11 @@ class MockMemoryPool : public velox::memory::MemoryPool {
         name, kind, parent, parent->capacity());
   }
 
-  MOCK_CONST_METHOD0(peakBytes, int64_t());
+  MOCK_METHOD(int64_t, peakBytes, (), (const, override));
 
   MOCK_METHOD1(updateSubtreeMemoryUsage, int64_t(int64_t));
 
-  MOCK_CONST_METHOD0(alignment, uint16_t());
+  MOCK_METHOD(uint16_t, alignment, (), (const, override));
 
   uint64_t freeBytes() const override {
     VELOX_UNSUPPORTED("{} unsupported", __FUNCTION__);

velox/dwio/parquet/writer/arrow/tests/FileDeserializeTest.cpp

@@ -350,13 +350,24 @@ void CheckDataPageHeader(
 
   const DataPageV1* data_page = static_cast<const DataPageV1*>(page);
   ASSERT_EQ(expected.num_values, data_page->num_values());
-  ASSERT_EQ(expected.encoding, data_page->encoding());
+  // The encoding enum for thrift::DataPageHeader isn't the same as in
+  // DataPageV1: parquet::thrift::Encoding::type vs
+  // parquet::arrow::Encoding::type.
   ASSERT_EQ(
-      expected.definition_level_encoding,
-      data_page->definition_level_encoding());
+      static_cast<std::underlying_type_t<thrift::Encoding::type>>(
+          expected.encoding),
+      static_cast<std::underlying_type_t<Encoding::type>>(
+          data_page->encoding()));
   ASSERT_EQ(
-      expected.repetition_level_encoding,
-      data_page->repetition_level_encoding());
+      static_cast<std::underlying_type_t<thrift::Encoding::type>>(
+          expected.definition_level_encoding),
+      static_cast<std::underlying_type_t<Encoding::type>>(
+          data_page->definition_level_encoding()));
+  ASSERT_EQ(
+      static_cast<std::underlying_type_t<thrift::Encoding::type>>(
+          expected.repetition_level_encoding),
+      static_cast<std::underlying_type_t<Encoding::type>>(
+          data_page->repetition_level_encoding()));
   CheckStatistics(expected, data_page->statistics());
 }
 
@@ -370,7 +381,14 @@ void CheckDataPageHeader(
   ASSERT_EQ(expected.num_values, data_page->num_values());
   ASSERT_EQ(expected.num_nulls, data_page->num_nulls());
   ASSERT_EQ(expected.num_rows, data_page->num_rows());
-  ASSERT_EQ(expected.encoding, data_page->encoding());
+  // The encoding enum for thrift::DataPageHeader isn't the same as in
+  // DataPageV2: parquet::thrift::Encoding::type vs
+  // parquet::arrow::Encoding::type.
+  ASSERT_EQ(
+      static_cast<std::underlying_type_t<thrift::Encoding::type>>(
+          expected.encoding),
+      static_cast<std::underlying_type_t<Encoding::type>>(
+          data_page->encoding()));
   ASSERT_EQ(
       expected.definition_levels_byte_length,
       data_page->definition_levels_byte_length());

velox/type/tests/TypeTest.cpp

@@ -678,10 +678,16 @@ class OpaqueWithMetadataType : public OpaqueType {
       : OpaqueType(std::type_index(typeid(OpaqueWithMetadata))),
         metadata(metadata) {}
 
+  bool operator==(const OpaqueWithMetadataType& other) const {
+    return OpaqueType::operator==(other) && other.metadata == metadata;
+  }
+
   bool operator==(const Type& other) const override {
-    return OpaqueType::operator==(other) &&
-        reinterpret_cast<const OpaqueWithMetadataType*>(&other)->metadata ==
-        metadata;
+    if (const auto* otherType =
+            reinterpret_cast<const OpaqueWithMetadataType*>(&other)) {
+      return (*this == *otherType);
+    }
+    return false;
   }
 
   folly::dynamic serialize() const override {