fix

zjw1111 · zjw1111 · commit beab600358e8 · 2025-12-18T18:42:28.000+08:00
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -77,7 +77,7 @@ repos:
         args:
           - "--quiet"
           - "--verbose=2"
-          - "--filter=-whitespace/line_length,-whitespace/parens,-whitespace/indent_namespace,-build/include_what_you_use,-build/c++11,-readability/nolint,-runtime/references"
+          - "--filter=-whitespace/line_length,-whitespace/parens,-whitespace/indent_namespace,-build/include_what_you_use,-build/c++11,-build/c++17,-readability/nolint,-runtime/references"
 
         types_or:
           - c++
diff --git a/src/paimon/common/data/binary_row_test.cpp b/src/paimon/common/data/binary_row_test.cpp
@@ -74,7 +74,7 @@ TEST_F(BinaryRowTest, TestBasic) {
     row.SetInt(0, 5);
     row.SetDouble(1, 5.8);
     ASSERT_EQ(5, row.GetInt(0));
-    ASSERT_EQ((double)5.8, row.GetDouble(1));
+    ASSERT_EQ(static_cast<double>(5.8), row.GetDouble(1));
 
     row.Clear();
     std::shared_ptr<Bytes> bytes1 = Bytes::AllocateBytes(100, pool.get());
@@ -405,10 +405,10 @@ TEST_F(BinaryRowTest, TestCompatibleWithJava) {
         int32_t arity = 1;
         BinaryRow row(arity);
         BinaryRowWriter writer(&row, 0, pool.get());
-        writer.WriteInt(0, static_cast<int32_t>(18));
+        writer.WriteInt(0, 18);
         writer.Complete();
 
-        ASSERT_EQ(row.GetInt(0), (int32_t)18);
+        ASSERT_EQ(row.GetInt(0), 18);
 
         auto bytes = SerializationUtils::SerializeBinaryRow(row, pool.get());
         std::string bytes_view(bytes->data(), bytes->size());
@@ -418,7 +418,7 @@ TEST_F(BinaryRowTest, TestCompatibleWithJava) {
         ASSERT_EQ(bytes_view, expect_view);
         ASSERT_OK_AND_ASSIGN(auto de_row, SerializationUtils::DeserializeBinaryRow(bytes));
         ASSERT_EQ(1, de_row.GetFieldCount());
-        ASSERT_EQ(de_row.GetInt(0), (int32_t)18);
+        ASSERT_EQ(de_row.GetInt(0), 18);
     }
 }
 
diff --git a/src/paimon/common/data/generic_row_test.cpp b/src/paimon/common/data/generic_row_test.cpp
@@ -78,13 +78,13 @@ TEST(GenericRowTest, TestSimple) {
     // test get
     ASSERT_FALSE(row.IsNullAt(0));
     ASSERT_EQ(row.GetBoolean(0), true);
-    ASSERT_EQ(row.GetByte(1), (char)1);
-    ASSERT_EQ(row.GetShort(2), (int16_t)2);
-    ASSERT_EQ(row.GetInt(3), (int32_t)3);
-    ASSERT_EQ(row.GetDate(3), (int32_t)3);
-    ASSERT_EQ(row.GetLong(4), (int64_t)4);
-    ASSERT_EQ(row.GetFloat(5), (float)5.1);
-    ASSERT_EQ(row.GetDouble(6), (double)6.12);
+    ASSERT_EQ(row.GetByte(1), static_cast<char>(1));
+    ASSERT_EQ(row.GetShort(2), static_cast<int16_t>(2));
+    ASSERT_EQ(row.GetInt(3), static_cast<int32_t>(3));
+    ASSERT_EQ(row.GetDate(3), static_cast<int32_t>(3));
+    ASSERT_EQ(row.GetLong(4), static_cast<int64_t>(4));
+    ASSERT_EQ(row.GetFloat(5), static_cast<float>(5.1));
+    ASSERT_EQ(row.GetDouble(6), static_cast<double>(6.12));
     ASSERT_EQ(row.GetString(7), str);
     ASSERT_EQ(*row.GetBinary(8), *bytes);
     ASSERT_EQ(std::string(row.GetStringView(9)), str9);
diff --git a/src/paimon/common/data/record_batch_test.cpp b/src/paimon/common/data/record_batch_test.cpp
@@ -58,7 +58,7 @@ TEST(RecordBatchTest, TestSimple) {
         ASSERT_TRUE(struct_builder.Append().ok());
         ASSERT_TRUE(string_builder->Append("20240813").ok());
         ASSERT_TRUE(int_builder->Append(23).ok());
-        ASSERT_TRUE(long_builder->Append((int64_t)1722848484308ll + i).ok());
+        ASSERT_TRUE(long_builder->Append(static_cast<int64_t>(1722848484308ll + i)).ok());
         ASSERT_TRUE(bool_builder->Append(static_cast<bool>(i % 2)).ok());
     }
     std::shared_ptr<arrow::Array> array;
diff --git a/src/paimon/common/memory/memory_segment.h b/src/paimon/common/memory/memory_segment.h
@@ -73,16 +73,16 @@ class PAIMON_EXPORT MemorySegment {
     template <typename T>
     inline void Get(int32_t index, T* dst, int32_t offset, int32_t length) const {
         // check the byte array offset and length and the status
-        assert((int32_t)dst->size() >= (offset + length));
-        assert((int32_t)heap_memory_->size() >= (index + length));
+        assert(static_cast<int32_t>(dst->size()) >= (offset + length));
+        assert(static_cast<int32_t>(heap_memory_->size()) >= (index + length));
         std::memcpy(const_cast<char*>(dst->data()) + offset, heap_memory_->data() + index, length);
     }
 
     template <typename T>
     inline void Put(int32_t index, const T& src, int32_t offset, int32_t length) {
         // check the byte array offset and length
-        assert((int32_t)src.size() >= (offset + length));
-        assert((int32_t)heap_memory_->size() >= (index + length));
+        assert(static_cast<int32_t>(src.size()) >= (offset + length));
+        assert(static_cast<int32_t>(heap_memory_->size()) >= (index + length));
         std::memcpy(heap_memory_->data() + index, src.data() + offset, length);
     }
 
diff --git a/src/paimon/common/memory/memory_segment_test.cpp b/src/paimon/common/memory/memory_segment_test.cpp
@@ -40,7 +40,8 @@ TEST(MemorySegmentTest, TestByteAccess) {
     }
     std::srand(seed);
     for (int32_t i = 0; i < page_size; i++) {
-        ASSERT_EQ(segment.Get(i), (char)std::rand()) << "seed: " << seed << ", idx: " << i;
+        ASSERT_EQ(segment.Get(i), static_cast<char>(std::rand()))
+            << "seed: " << seed << ", idx: " << i;
     }
 
     // test expected correct behavior, random access
@@ -72,7 +73,8 @@ TEST(MemorySegmentTest, TestByteAccess) {
             occupied[pos] = true;
         }
 
-        ASSERT_EQ(segment.Get(pos), (char)std::rand()) << "seed: " << seed << ", idx: " << pos;
+        ASSERT_EQ(segment.Get(pos), static_cast<char>(std::rand()))
+            << "seed: " << seed << ", idx: " << pos;
     }
     delete[] occupied;
 }
@@ -197,7 +199,7 @@ TEST(MemorySegmentTest, TestCharAccess) {
 
     std::srand(seed);
     for (int32_t i = 0; i <= page_size - 2; i += 2) {
-        ASSERT_EQ(segment.GetValue<char16_t>(i), (char)(std::rand() % (CHAR_MAX)))
+        ASSERT_EQ(segment.GetValue<char16_t>(i), static_cast<char>(std::rand() % (CHAR_MAX)))
             << "seed: " << seed << ", idx: " << i;
     }
 
@@ -231,7 +233,7 @@ TEST(MemorySegmentTest, TestCharAccess) {
             occupied[pos + 1] = true;
         }
 
-        ASSERT_EQ(segment.GetValue<char16_t>(pos), (char)(std::rand() % (CHAR_MAX)))
+        ASSERT_EQ(segment.GetValue<char16_t>(pos), static_cast<char>(std::rand() % (CHAR_MAX)))
             << "seed: " << seed << ", idx:" << pos;
     }
     delete[] occupied;
@@ -251,7 +253,7 @@ TEST(MemorySegmentTest, TestShortAccess) {
 
     std::srand(seed);
     for (int32_t i = 0; i <= page_size - 2; i += 2) {
-        ASSERT_EQ(segment.GetValue<int16_t>(i), (int16_t)std::rand())
+        ASSERT_EQ(segment.GetValue<int16_t>(i), static_cast<int16_t>(std::rand()))
             << "seed: " << seed << ", idx:" << i;
     }
 
@@ -285,7 +287,7 @@ TEST(MemorySegmentTest, TestShortAccess) {
             occupied[pos + 1] = true;
         }
 
-        ASSERT_EQ(segment.GetValue<int16_t>(pos), (int16_t)std::rand())
+        ASSERT_EQ(segment.GetValue<int16_t>(pos), static_cast<int16_t>(std::rand()))
             << "seed: " << seed << ", idx:" << pos;
     }
     delete[] occupied;
@@ -305,7 +307,7 @@ TEST(MemorySegmentTest, TestIntAccess) {
 
     std::srand(seed);
     for (int32_t i = 0; i <= page_size - 4; i += 4) {
-        ASSERT_EQ(segment.GetValue<int32_t>(i), (int32_t)std::rand())
+        ASSERT_EQ(segment.GetValue<int32_t>(i), static_cast<int32_t>(std::rand()))
             << "seed: " << seed << ", idx:" << i;
     }
 
@@ -343,7 +345,7 @@ TEST(MemorySegmentTest, TestIntAccess) {
             occupied[pos + 3] = true;
         }
 
-        ASSERT_EQ(segment.GetValue<int32_t>(pos), (int32_t)std::rand())
+        ASSERT_EQ(segment.GetValue<int32_t>(pos), static_cast<int32_t>(std::rand()))
             << "seed: " << seed << ", idx:" << pos;
     }
     delete[] occupied;
diff --git a/src/paimon/common/predicate/predicate_validator_test.cpp b/src/paimon/common/predicate/predicate_validator_test.cpp
@@ -150,7 +150,7 @@ TEST(PredicateValidatorTest, TestValidateSchema) {
                 PredicateBuilder::Equal(/*field_index=*/7, /*field_name=*/"f7", FieldType::BINARY,
                                         Literal(FieldType::BINARY, str.data(), str.size())),
                 PredicateBuilder::Equal(/*field_index=*/8, /*field_name=*/"f8", FieldType::TINYINT,
-                                        Literal((int8_t)20)),
+                                        Literal(static_cast<int8_t>(20))),
             }));
         ASSERT_OK(PredicateValidator::ValidatePredicateWithSchema(*schema, predicate,
                                                                   /*validate_field_idx=*/true));
diff --git a/src/paimon/common/utils/bloom_filter64_test.cpp b/src/paimon/common/utils/bloom_filter64_test.cpp
@@ -56,7 +56,7 @@ TEST(BloomFilter64Test, TestSimple) {
             false_positives++;
         }
     }
-    ASSERT_TRUE((double)false_positives / num < 0.03);
+    ASSERT_TRUE(static_cast<double>(false_positives) / num < 0.03);
 }
 
 TEST(BloomFilter64Test, TestCompatibleWithJava) {
diff --git a/src/paimon/common/utils/concurrent_hash_map_test.cpp b/src/paimon/common/utils/concurrent_hash_map_test.cpp
@@ -141,7 +141,7 @@ TEST(ConcurrentHashMapTest, TestMultiThreadInsertAndFindAndDelete) {
         thread3.join();
 
         // check final states
-        ASSERT_TRUE(hash_map.Size() >= 0 && hash_map.Size() <= (size_t)map_size);
+        ASSERT_TRUE(hash_map.Size() >= 0 && hash_map.Size() <= static_cast<size_t>(map_size));
         for (int32_t i = 0; i < map_size; i++) {
             auto value = hash_map.Find(i);
             if (value) {
diff --git a/src/paimon/common/utils/projected_row_test.cpp b/src/paimon/common/utils/projected_row_test.cpp
@@ -85,13 +85,13 @@ TEST(ProjectedRowTest, TestSimple) {
     ASSERT_TRUE(projected_row.IsNullAt(16));
 
     ASSERT_EQ(projected_row.GetBoolean(15), true);
-    ASSERT_EQ(projected_row.GetByte(14), (char)1);
-    ASSERT_EQ(projected_row.GetShort(13), (int16_t)2);
-    ASSERT_EQ(projected_row.GetInt(12), (int32_t)3);
-    ASSERT_EQ(projected_row.GetDate(12), (int32_t)3);
-    ASSERT_EQ(projected_row.GetLong(11), (int64_t)4);
-    ASSERT_EQ(projected_row.GetFloat(10), (float)5.1);
-    ASSERT_EQ(projected_row.GetDouble(9), (double)6.12);
+    ASSERT_EQ(projected_row.GetByte(14), static_cast<char>(1));
+    ASSERT_EQ(projected_row.GetShort(13), static_cast<int16_t>(2));
+    ASSERT_EQ(projected_row.GetInt(12), static_cast<int32_t>(3));
+    ASSERT_EQ(projected_row.GetDate(12), static_cast<int32_t>(3));
+    ASSERT_EQ(projected_row.GetLong(11), static_cast<int64_t>(4));
+    ASSERT_EQ(projected_row.GetFloat(10), static_cast<float>(5.1));
+    ASSERT_EQ(projected_row.GetDouble(9), static_cast<double>(6.12));
     ASSERT_EQ(projected_row.GetString(8), str);
     ASSERT_EQ(*projected_row.GetBinary(7), *bytes);
     ASSERT_EQ(std::string(projected_row.GetStringView(6)), str9);
diff --git a/src/paimon/common/utils/string_utils_test.cpp b/src/paimon/common/utils/string_utils_test.cpp
@@ -307,10 +307,11 @@ TEST_F(StringUtilsTest, TestSplit) {
 }
 
 TEST_F(StringUtilsTest, TestStringToValueSimple) {
-    ASSERT_EQ((int32_t)233, StringUtils::StringToValue<int32_t>("233").value());
-    ASSERT_EQ((int8_t)10, StringUtils::StringToValue<int8_t>("10").value());
+    ASSERT_EQ(static_cast<int32_t>(233), StringUtils::StringToValue<int32_t>("233").value());
+    ASSERT_EQ(static_cast<int8_t>(10), StringUtils::StringToValue<int8_t>("10").value());
     ASSERT_EQ(std::nullopt, StringUtils::StringToValue<int8_t>("1024"));
-    ASSERT_EQ((int64_t)34785895352ll, StringUtils::StringToValue<int64_t>("34785895352").value());
+    ASSERT_EQ(static_cast<int64_t>(34785895352),
+              StringUtils::StringToValue<int64_t>("34785895352").value());
     ASSERT_EQ(std::nullopt, StringUtils::StringToValue<int32_t>("abc"));
     ASSERT_EQ(std::nullopt, StringUtils::StringToValue<int32_t>(""));
 
diff --git a/src/paimon/core/casting/casted_row_test.cpp b/src/paimon/core/casting/casted_row_test.cpp
@@ -61,14 +61,14 @@ TEST(CastedRowTest, TestSimpleWithNoCasting) {
     ASSERT_EQ(casted_row->GetFieldCount(), 10);
     ASSERT_EQ(casted_row->GetRowKind().value(), RowKind::Insert());
     ASSERT_EQ(casted_row->GetBoolean(0), true);
-    ASSERT_EQ(casted_row->GetByte(1), (char)0);
-    ASSERT_EQ(casted_row->GetShort(2), (int16_t)32767);
+    ASSERT_EQ(casted_row->GetByte(1), static_cast<char>(0));
+    ASSERT_EQ(casted_row->GetShort(2), static_cast<int16_t>(32767));
     ASSERT_FALSE(casted_row->IsNullAt(3));
-    ASSERT_EQ(casted_row->GetInt(3), (int32_t)2147483647);
+    ASSERT_EQ(casted_row->GetInt(3), static_cast<int32_t>(2147483647));
     ASSERT_TRUE(casted_row->IsNullAt(4));
-    ASSERT_EQ(casted_row->GetLong(5), (int64_t)4294967295);
-    ASSERT_EQ(casted_row->GetFloat(6), (float)0.5);
-    ASSERT_EQ(casted_row->GetDouble(7), (double)1.141592659);
+    ASSERT_EQ(casted_row->GetLong(5), static_cast<int64_t>(4294967295));
+    ASSERT_EQ(casted_row->GetFloat(6), static_cast<float>(0.5));
+    ASSERT_EQ(casted_row->GetDouble(7), static_cast<double>(1.141592659));
     ASSERT_EQ(casted_row->GetString(8).ToString(), "2025-03-27");
     ASSERT_EQ(*casted_row->GetBinary(9), Bytes("banana", pool.get()));
 
diff --git a/src/paimon/core/io/field_mapping_reader_test.cpp b/src/paimon/core/io/field_mapping_reader_test.cpp
@@ -292,7 +292,7 @@ TEST_F(FieldMappingReaderTest, TestGenerateSinglePartitionArray) {
         ASSERT_EQ(
             arrow::internal::checked_cast<arrow::NumericArray<arrow::Int16Type>*>(p2_array.get())
                 ->Value(0),
-            (int16_t)2);
+            static_cast<int16_t>(2));
     }
     {
         ASSERT_OK_AND_ASSIGN(auto p1_array, mapping_reader->GenerateSinglePartitionArray(
diff --git a/src/paimon/core/utils/offset_row_test.cpp b/src/paimon/core/utils/offset_row_test.cpp
@@ -43,13 +43,13 @@ TEST(OffsetRowTest, TestSimple) {
     ASSERT_EQ(row.GetRowKind().value(), RowKind::Insert());
     ASSERT_EQ(row.GetFieldCount(), 12);
     ASSERT_FALSE(row.IsNullAt(0));
-    ASSERT_EQ(row.GetByte(0), (char)1);
-    ASSERT_EQ(row.GetShort(1), (int16_t)11);
-    ASSERT_EQ(row.GetInt(2), (int32_t)111);
-    ASSERT_EQ(row.GetDate(2), (int32_t)111);
-    ASSERT_EQ(row.GetLong(3), (int64_t)1111);
-    ASSERT_EQ(row.GetFloat(4), (float)12.3);
-    ASSERT_EQ(row.GetDouble(5), (double)12.34);
+    ASSERT_EQ(row.GetByte(0), static_cast<char>(1));
+    ASSERT_EQ(row.GetShort(1), static_cast<int16_t>(11));
+    ASSERT_EQ(row.GetInt(2), static_cast<int32_t>(111));
+    ASSERT_EQ(row.GetDate(2), static_cast<int32_t>(111));
+    ASSERT_EQ(row.GetLong(3), static_cast<int64_t>(1111));
+    ASSERT_EQ(row.GetFloat(4), static_cast<float>(12.3));
+    ASSERT_EQ(row.GetDouble(5), static_cast<double>(12.34));
     ASSERT_EQ(row.GetBoolean(6), false);
     ASSERT_EQ(row.GetString(7).ToString(), "hello");
     ASSERT_EQ(*row.GetBinary(8), *bytes);
diff --git a/src/paimon/format/orc/orc_format_writer.cpp b/src/paimon/format/orc/orc_format_writer.cpp
@@ -129,11 +129,11 @@ Status OrcFormatWriter::AddBatch(ArrowArray* batch) {
     assert(batch);
     PAIMON_ASSIGN_OR_RAISE_FROM_ARROW(std::shared_ptr<arrow::Array> arrow_array,
                                       arrow::ImportArray(batch, data_type_));
-    if (PAIMON_UNLIKELY((uint64_t)arrow_array->length() > orc_batch_->capacity)) {
+    if (PAIMON_UNLIKELY(static_cast<uint64_t>(arrow_array->length()) > orc_batch_->capacity)) {
         PAIMON_RETURN_NOT_OK(ExpandBatch(arrow_array->length()));
     }
     PAIMON_RETURN_NOT_OK(OrcAdapter::WriteBatch(arrow_array, orc_batch_.get()));
-    assert(orc_batch_->numElements == (uint64_t)arrow_array->length());
+    assert(orc_batch_->numElements == static_cast<uint64_t>(arrow_array->length()));
     PAIMON_RETURN_NOT_OK(Flush());
     return Status::OK();
 }
diff --git a/src/paimon/fs/local/local_file_system.cpp b/src/paimon/fs/local/local_file_system.cpp
@@ -288,7 +288,7 @@ void LocalInputStream::ReadAsync(char* buffer, uint32_t size, uint64_t offset,
     if (!read_size.ok()) {
         status = read_size.status();
     } else {
-        assert(read_size.value() == (int32_t)size);
+        assert(read_size.value() == static_cast<int32_t>(size));
     }
     callback(status);
 }

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ TEST(RecordBatchTest, TestSimple) {`
`58`	`58`	`ASSERT_TRUE(struct_builder.Append().ok());`
`59`	`59`	`ASSERT_TRUE(string_builder->Append("20240813").ok());`
`60`	`60`	`ASSERT_TRUE(int_builder->Append(23).ok());`
`61`		`- ASSERT_TRUE(long_builder->Append((int64_t)1722848484308ll + i).ok());`
	`61`	`+ ASSERT_TRUE(long_builder->Append(static_cast<int64_t>(1722848484308ll + i)).ok());`
`62`	`62`	`ASSERT_TRUE(bool_builder->Append(static_cast<bool>(i % 2)).ok());`
`63`	`63`	`}`
`64`	`64`	`std::shared_ptr<arrow::Array> array;`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,8 @@ TEST(MemorySegmentTest, TestByteAccess) {`
`40`	`40`	`}`
`41`	`41`	`std::srand(seed);`
`42`	`42`	`for (int32_t i = 0; i < page_size; i++) {`
`43`		`- ASSERT_EQ(segment.Get(i), (char)std::rand()) << "seed: " << seed << ", idx: " << i;`
	`43`	`+ ASSERT_EQ(segment.Get(i), static_cast<char>(std::rand()))`
	`44`	`+ << "seed: " << seed << ", idx: " << i;`
`44`	`45`	`}`
`45`	`46`
`46`	`47`	`// test expected correct behavior, random access`
`@@ -72,7 +73,8 @@ TEST(MemorySegmentTest, TestByteAccess) {`
`72`	`73`	`occupied[pos] = true;`
`73`	`74`	`}`
`74`	`75`
`75`		`- ASSERT_EQ(segment.Get(pos), (char)std::rand()) << "seed: " << seed << ", idx: " << pos;`
	`76`	`+ ASSERT_EQ(segment.Get(pos), static_cast<char>(std::rand()))`
	`77`	`+ << "seed: " << seed << ", idx: " << pos;`
`76`	`78`	`}`
`77`	`79`	`delete[] occupied;`
`78`	`80`	`}`
`@@ -197,7 +199,7 @@ TEST(MemorySegmentTest, TestCharAccess) {`
`197`	`199`
`198`	`200`	`std::srand(seed);`
`199`	`201`	`for (int32_t i = 0; i <= page_size - 2; i += 2) {`
`200`		`- ASSERT_EQ(segment.GetValue<char16_t>(i), (char)(std::rand() % (CHAR_MAX)))`
	`202`	`+ ASSERT_EQ(segment.GetValue<char16_t>(i), static_cast<char>(std::rand() % (CHAR_MAX)))`
`201`	`203`	`<< "seed: " << seed << ", idx: " << i;`
`202`	`204`	`}`
`203`	`205`
`@@ -231,7 +233,7 @@ TEST(MemorySegmentTest, TestCharAccess) {`
`231`	`233`	`occupied[pos + 1] = true;`
`232`	`234`	`}`
`233`	`235`
`234`		`- ASSERT_EQ(segment.GetValue<char16_t>(pos), (char)(std::rand() % (CHAR_MAX)))`
	`236`	`+ ASSERT_EQ(segment.GetValue<char16_t>(pos), static_cast<char>(std::rand() % (CHAR_MAX)))`
`235`	`237`	`<< "seed: " << seed << ", idx:" << pos;`
`236`	`238`	`}`
`237`	`239`	`delete[] occupied;`
`@@ -251,7 +253,7 @@ TEST(MemorySegmentTest, TestShortAccess) {`
`251`	`253`
`252`	`254`	`std::srand(seed);`
`253`	`255`	`for (int32_t i = 0; i <= page_size - 2; i += 2) {`
`254`		`- ASSERT_EQ(segment.GetValue<int16_t>(i), (int16_t)std::rand())`
	`256`	`+ ASSERT_EQ(segment.GetValue<int16_t>(i), static_cast<int16_t>(std::rand()))`
`255`	`257`	`<< "seed: " << seed << ", idx:" << i;`
`256`	`258`	`}`
`257`	`259`
`@@ -285,7 +287,7 @@ TEST(MemorySegmentTest, TestShortAccess) {`
`285`	`287`	`occupied[pos + 1] = true;`
`286`	`288`	`}`
`287`	`289`
`288`		`- ASSERT_EQ(segment.GetValue<int16_t>(pos), (int16_t)std::rand())`
	`290`	`+ ASSERT_EQ(segment.GetValue<int16_t>(pos), static_cast<int16_t>(std::rand()))`
`289`	`291`	`<< "seed: " << seed << ", idx:" << pos;`
`290`	`292`	`}`
`291`	`293`	`delete[] occupied;`
`@@ -305,7 +307,7 @@ TEST(MemorySegmentTest, TestIntAccess) {`
`305`	`307`
`306`	`308`	`std::srand(seed);`
`307`	`309`	`for (int32_t i = 0; i <= page_size - 4; i += 4) {`
`308`		`- ASSERT_EQ(segment.GetValue<int32_t>(i), (int32_t)std::rand())`
	`310`	`+ ASSERT_EQ(segment.GetValue<int32_t>(i), static_cast<int32_t>(std::rand()))`
`309`	`311`	`<< "seed: " << seed << ", idx:" << i;`
`310`	`312`	`}`
`311`	`313`
`@@ -343,7 +345,7 @@ TEST(MemorySegmentTest, TestIntAccess) {`
`343`	`345`	`occupied[pos + 3] = true;`
`344`	`346`	`}`
`345`	`347`
`346`		`- ASSERT_EQ(segment.GetValue<int32_t>(pos), (int32_t)std::rand())`
	`348`	`+ ASSERT_EQ(segment.GetValue<int32_t>(pos), static_cast<int32_t>(std::rand()))`
`347`	`349`	`<< "seed: " << seed << ", idx:" << pos;`
`348`	`350`	`}`
`349`	`351`	`delete[] occupied;`
Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ TEST(BloomFilter64Test, TestSimple) {`
`56`	`56`	`false_positives++;`
`57`	`57`	`}`
`58`	`58`	`}`
`59`		`- ASSERT_TRUE((double)false_positives / num < 0.03);`
	`59`	`+ ASSERT_TRUE(static_cast<double>(false_positives) / num < 0.03);`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`TEST(BloomFilter64Test, TestCompatibleWithJava) {`