| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| |
| #include <gtest/gtest.h> |
| #include <rapidjson/document.h> |
| #include <re2/re2.h> |
| |
| #include <string> |
| |
| namespace doris { |
| |
| class EsScrollParserTest : public testing::Test { |
| public: |
| void SetUp() override {} |
| void TearDown() override {} |
| }; |
| |
| // Test timezone pattern matching for ES datetime parsing fix |
| TEST_F(EsScrollParserTest, TestTimezonePatternMatching) { |
| RE2 time_zone_pattern(R"([+-]\d{2}:?\d{2}|Z)"); |
| |
| std::vector<std::string> valid_timezone_formats = { |
| "2025-05-23T20:56:52.052+0900", "2025-05-23T20:56:52.052-0500", |
| "2025-05-23T20:56:52.052+08:00", "2025-05-23T20:56:52.052-04:30", |
| "2025-05-23T20:56:52.052Z", "2022-08-08T12:10:10.151Z", |
| "2022-08-08T12:10:10+0900", "2022-08-08T12:10:10-0500"}; |
| |
| for (const auto& datetime_str : valid_timezone_formats) { |
| re2::StringPiece timezone_value; |
| bool matched = time_zone_pattern.Match(datetime_str, 0, datetime_str.size(), |
| RE2::UNANCHORED, &timezone_value, 1); |
| EXPECT_TRUE(matched) << "Failed to match timezone in: " << datetime_str; |
| |
| std::string timezone = timezone_value.as_string(); |
| EXPECT_FALSE(timezone.empty()) << "Empty timezone captured from: " << datetime_str; |
| |
| if (timezone == "Z") { |
| EXPECT_EQ(timezone, "Z"); |
| } else { |
| EXPECT_TRUE(timezone[0] == '+' || timezone[0] == '-') |
| << "Invalid timezone sign in: " << timezone; |
| // Valid timezone lengths: 5 for +0900, 6 for +08:00 |
| EXPECT_TRUE(timezone.length() == 5 || timezone.length() == 6) |
| << "Invalid timezone length in: " << timezone |
| << " (length: " << timezone.length() << ")"; |
| } |
| } |
| } |
| |
| TEST_F(EsScrollParserTest, TestInvalidTimezonePatterns) { |
| RE2 time_zone_pattern(R"([+-]\d{2}:?\d{2}|Z)"); |
| |
| std::vector<std::string> invalid_formats = { |
| "2025-05-23T20:56:52.052", "2025-05-23T20:56:52.052+9", "2025-05-23T20:56:52.052+090", |
| "2025-05-23T20:56:52.052+9:00"}; |
| |
| for (const auto& datetime_str : invalid_formats) { |
| re2::StringPiece timezone_value; |
| bool matched = time_zone_pattern.Match(datetime_str, 0, datetime_str.size(), |
| RE2::UNANCHORED, &timezone_value, 1); |
| if (matched) { |
| std::string timezone = timezone_value.as_string(); |
| EXPECT_TRUE(timezone.empty()) << "Should not capture timezone from: " << datetime_str; |
| } |
| } |
| } |
| |
| TEST_F(EsScrollParserTest, TestBugScenarioTimezoneFormat) { |
| RE2 time_zone_pattern(R"([+-]\d{2}:?\d{2}|Z)"); |
| |
| std::string problematic_format = "2025-05-23T20:56:52.052+0900"; |
| |
| re2::StringPiece timezone_value; |
| bool matched = time_zone_pattern.Match(problematic_format, 0, problematic_format.size(), |
| RE2::UNANCHORED, &timezone_value, 1); |
| |
| EXPECT_TRUE(matched) << "Failed to match the bug scenario format: " << problematic_format; |
| |
| std::string timezone = timezone_value.as_string(); |
| EXPECT_EQ(timezone, "+0900") << "Incorrect timezone captured: " << timezone; |
| } |
| |
| TEST_F(EsScrollParserTest, TestEdgeCaseTimezoneFormats) { |
| RE2 time_zone_pattern(R"([+-]\d{2}:?\d{2}|Z)"); |
| |
| std::vector<std::string> edge_cases = {"+00:00", "-00:00", "+23:59", "-23:59", |
| "+99:99", "Z", "+0800", ""}; |
| |
| // Test each edge case |
| std::vector<std::string> test_datetime_strings = { |
| "2025-05-23T20:56:52.052+00:00", // +00:00 (UTC with colon) |
| "2025-05-23T20:56:52.052-00:00", // -00:00 (UTC with colon) |
| "2025-05-23T20:56:52.052+23:59", // +23:59 (max valid timezone) |
| "2025-05-23T20:56:52.052-23:59", // -23:59 (max valid timezone) |
| "2025-05-23T20:56:52.052+99:99", // +99:99 (invalid but should match pattern) |
| "2025-05-23T20:56:52.052Z", // Z (UTC) |
| "2025-05-23T20:56:52.052+0800", // +0800 (no colon) |
| "2025-05-23T20:56:52.052" // empty timezone (no timezone) |
| }; |
| |
| std::vector<std::string> expected_matches = {"+00:00", "-00:00", "+23:59", "-23:59", |
| "+99:99", "Z", "+0800", ""}; |
| |
| std::vector<bool> should_match = {true, true, true, true, true, true, true, false}; |
| |
| for (size_t i = 0; i < test_datetime_strings.size(); ++i) { |
| const std::string& datetime_str = test_datetime_strings[i]; |
| const std::string& expected_match = expected_matches[i]; |
| bool should_match_expected = should_match[i]; |
| |
| re2::StringPiece timezone_value; |
| bool matched = time_zone_pattern.Match(datetime_str, 0, datetime_str.size(), |
| RE2::UNANCHORED, &timezone_value, 1); |
| |
| EXPECT_EQ(matched, should_match_expected) |
| << "Edge case test failed for: " << datetime_str |
| << " (expected match: " << should_match_expected << ")"; |
| |
| if (matched && should_match_expected) { |
| std::string timezone = timezone_value.as_string(); |
| EXPECT_EQ(timezone, expected_match) |
| << "Incorrect timezone captured from: " << datetime_str |
| << " (expected: " << expected_match << ", got: " << timezone << ")"; |
| } |
| } |
| } |
| |
| TEST_F(EsScrollParserTest, TestSpecialTimezoneEdgeCases) { |
| RE2 time_zone_pattern(R"([+-]\d{2}:?\d{2}|Z)"); |
| |
| // Additional edge cases for comprehensive testing |
| std::vector<std::pair<std::string, std::pair<std::string, bool>>> special_cases = { |
| // {datetime_string, {expected_timezone, should_match}} |
| {"2025-05-23T20:56:52+0000", {"+0000", true}}, // +0000 without colon |
| {"2025-05-23T20:56:52-0000", {"-0000", true}}, // -0000 without colon |
| {"2025-05-23T20:56:52+12:30", {"+12:30", true}}, // +12:30 with colon |
| {"2025-05-23T20:56:52-12:30", {"-12:30", true}}, // -12:30 with colon |
| {"2025-05-23T20:56:52+1200", {"+1200", true}}, // +1200 without colon |
| {"2025-05-23T20:56:52-1200", {"-1200", true}}, // -1200 without colon |
| {"2025-05-23T20:56:52.000Z", {"Z", true}}, // Z with milliseconds |
| {"2025-05-23T20:56:52.123456+05:30", {"+05:30", true}}, // microseconds with timezone |
| {"2025-05-23T20:56:52.123456-05:30", {"-05:30", true}}, // microseconds with timezone |
| {"2025-05-23T20:56:52.123456+0530", {"+0530", true}}, // microseconds without colon |
| {"2025-05-23T20:56:52.123456-0530", {"-0530", true}}, // microseconds without colon |
| {"2025-05-23T20:56:52+14:00", {"+14:00", true}}, // +14:00 (valid max timezone) |
| {"2025-05-23T20:56:52-12:00", {"-12:00", true}}, // -12:00 (valid min timezone) |
| }; |
| |
| for (const auto& test_case : special_cases) { |
| const std::string& datetime_str = test_case.first; |
| const std::string& expected_timezone = test_case.second.first; |
| bool should_match = test_case.second.second; |
| |
| re2::StringPiece timezone_value; |
| bool matched = time_zone_pattern.Match(datetime_str, 0, datetime_str.size(), |
| RE2::UNANCHORED, &timezone_value, 1); |
| |
| EXPECT_EQ(matched, should_match) << "Special case test failed for: " << datetime_str |
| << " (expected match: " << should_match << ")"; |
| |
| if (matched && should_match) { |
| std::string timezone = timezone_value.as_string(); |
| EXPECT_EQ(timezone, expected_timezone) |
| << "Incorrect timezone captured from: " << datetime_str |
| << " (expected: " << expected_timezone << ", got: " << timezone << ")"; |
| } |
| } |
| } |
| |
| } // namespace doris |
