Add date/time parser tests.

Author: MeanSquaredError

tests/core/usage/CMakeLists.txt

@@ -33,6 +33,7 @@ set(test_files
     BooleanExpression.cpp
     CustomQuery.cpp
     DateTime.cpp
+    DateTimeParser.cpp
     Interpret.cpp
     Insert.cpp
     Remove.cpp
@@ -77,4 +78,4 @@ endforeach()
 #	OUTPUT "${CMAKE_CURRENT_LIST_DIR}/Sample.h"
 #	COMMAND "${PYTHON_EXECUTABLE}" "${CMAKE_SOURCE_DIR}/scripts/ddl2cpp" "${CMAKE_CURRENT_LIST_DIR}/sample.sql" Sample test
 #	DEPENDS "${CMAKE_CURRENT_LIST_DIR}/sample.sql"
-#	VERBATIM)
+#	VERBATIM)

tests/core/usage/DateTimeParser.cpp

@@ -0,0 +1,303 @@
+/*
+ * Copyright (c) 2023, Vesselin Atanasov
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sqlpp11/detail/parse_date_time.h>
+#include <sqlpp11/sqlpp11.h>
+
+#include <iostream>
+#include <vector>
+
+namespace
+{
+  template <typename L, typename R>
+  void require_equal(int line, const L& l, const R& r)
+  {
+    if (l != r)
+    {
+      std::cerr << line << ": ";
+      serialize(sqlpp::wrap_operand_t<L>{l}, std::cerr);
+      std::cerr << " != ";
+      serialize(sqlpp::wrap_operand_t<R>{r}, std::cerr);
+      std::cerr << std::endl;
+      throw std::runtime_error("Unexpected result");
+    }
+  }
+
+  void test_valid_dates()
+  {
+    using namespace sqlpp::chrono;
+    using namespace date;
+
+    for (const auto& date_pair : std::vector<std::pair<const char*, day_point>>{
+      // Minimum and maximum dates
+      {"0001-01-01", year{1}/1/1}, {"9999-12-31", year{9999}/12/31},
+      // Month minimum and maximum days
+      {"1999-01-01", year{1999}/1/1}, {"1999-01-31", year{1999}/1/31},
+      {"1999-02-01", year{1999}/2/1}, {"1999-02-28", year{1999}/2/28},
+      {"1999-03-01", year{1999}/3/1}, {"1999-03-31", year{1999}/3/31},
+      {"1999-04-01", year{1999}/4/1}, {"1999-04-30", year{1999}/4/30},
+      {"1999-05-01", year{1999}/5/1}, {"1999-05-31", year{1999}/5/31},
+      {"1999-06-01", year{1999}/6/1}, {"1999-06-30", year{1999}/6/30},
+      {"1999-07-01", year{1999}/7/1}, {"1999-07-31", year{1999}/7/31},
+      {"1999-08-01", year{1999}/8/1}, {"1999-08-31", year{1999}/8/31},
+      {"1999-09-01", year{1999}/9/1}, {"1999-09-30", year{1999}/9/30},
+      {"1999-10-01", year{1999}/10/1}, {"1999-10-31", year{1999}/10/31},
+      {"1999-11-01", year{1999}/11/1}, {"1999-11-30", year{1999}/11/30},
+      {"1999-12-01", year{1999}/12/1}, {"1999-12-31", year{1999}/12/31},
+      // YYYY-02-29
+      {"2396-02-29", year{2396}/2/29},
+      {"2400-02-29", year{2400}/2/29}
+    })
+    {
+      day_point dp;
+      if (sqlpp::detail::parse_date(dp, date_pair.first) == false)
+      {
+        std::cerr << "Could not parse a valid date string: " << date_pair.first << std::endl;
+        throw std::runtime_error{"Parse error"};
+      }
+      require_equal(__LINE__, dp, date_pair.second);
+    }
+  }
+
+  void test_invalid_dates()
+  {
+    using namespace sqlpp::chrono;
+
+    for (const auto& date_str : std::vector<const char*>{
+      // Invalid year
+      "", "1", "12", "123" , "1234", "A",
+      // Invalid month
+      "1980--02", "1980-1-02", "1980-00-02", "1980-123-02", "1980-13-02", "1980-W-02",
+      // Invalid day
+      "1980-01-", "1980-01-0", "1980-01-00", "1980-01-32", "1980-01-123", "1980-01-Q",
+      // Invalid separator
+      "1980 01 02", "1980- 01-02", "1980 -01-02", "1980-01 -02", "1980-01- 02", "1980-01T02"
+      // Invalid YYYY-02-29
+      "1981-02-29", "2100-02-29",
+      // Trailing characters
+      "1980-01-02 ", "1980-01-02T", "1980-01-02 UTC", "1980-01-02EST", "1980-01-02+01"
+    })
+    {
+      day_point dp;
+      if (sqlpp::detail::parse_date(dp, date_str))
+      {
+        std::cerr << "Parsed successfully an invalid date string " << date_str << ", value ";
+        serialize(sqlpp::wrap_operand_t<day_point>{dp}, std::cerr);
+        std::cerr << std::endl;
+        throw std::runtime_error{"Parse error"};
+      }
+    }
+  }
+
+  void test_valid_time_of_day()
+  {
+    using namespace std::chrono;
+
+    for (const auto& tod_pair : std::vector<std::pair<const char*, microseconds>>{
+      // Minimum value
+      {"00:00:00", hours{0}},
+      // Maximum hours
+      {"23:00:00", hours{23}},
+      // Maximum minutes
+      {"00:59:00", minutes{59}},
+      // Maximum seconds
+      {"00:00:59", seconds{59}},
+      // Second fractions
+      {"01:23:54.000001", hours{1} + minutes{23} + seconds{54} + microseconds{1}},
+      {"01:23:54.999999", hours{1} + minutes{23} + seconds{54} + microseconds{999999}},
+      // Timezone offsets
+      {"10:09:08+03", hours{10} + minutes{9} + seconds{8} - hours{3}},
+      {"10:09:08-03", hours{10} + minutes{9} + seconds{8} + hours{3}},
+      {"10:09:08+03:02", hours{10} + minutes{9} + seconds{8} - (hours{3} + minutes{2})},
+      {"10:09:08-03:02", hours{10} + minutes{9} + seconds{8} + (hours{3} + minutes{2})},
+      {"10:09:08+13:12:11", hours{10} + minutes{9} + seconds{8} - (hours{13} + minutes{12} + seconds{11})},
+      {"10:09:08-13:12:11", hours{10} + minutes{9} + seconds{8} + (hours{13} + minutes{12} + seconds{11})},
+      // Second fraction and timezone offset
+      {"10:09:08.1+03", hours{10} + minutes{9} + seconds{8} + microseconds{100000} - hours{3}},
+      {"10:09:08.12-07:40", hours{10} + minutes{9} + seconds{8} + microseconds{120000} + (hours{7} + minutes{40})},
+      {"10:09:08.123+12:38:49", hours{10} + minutes{9} + seconds{8} + microseconds{123000} - (hours{12} + minutes{38} + seconds{49})}
+    })
+    {
+      microseconds us;
+      if (sqlpp::detail::parse_time_of_day(us, tod_pair.first) == false)
+      {
+        std::cerr << "Could not parse a valid time-of-day string: " << tod_pair.first << std::endl;
+        throw std::runtime_error{"Parse error"};
+      }
+      require_equal(__LINE__, us, tod_pair.second);
+    }
+  }
+
+  void test_invalid_time_of_day()
+  {
+    using namespace std::chrono;
+
+    for (const auto& tod_str : std::vector<const char*>{
+      // Generic string
+      "A", "BC", "!()",
+      // Invalid hour
+      "-01:23:45", "25:00:10", "AA:10:11",
+      // Invalid minute
+      "13::07", "13:A:07", "13:1:07", "13:-01:07"
+      // Invalid second
+      "04:07:", "04:07:A", "04:07:1", "04:07:-01"
+      // Invalid fraction
+      "01:02:03.", "01:02:03.A", "01:02:03.1234567", "01:02:03.1A2",
+      // Invalid timezone
+      "01:03:03!01", "01:03:03+A", "01:03:03+1", "01:03:03+1A", "01:03:03+456",
+      "01:03:03+12:", "01:03:03+12:1", "01:03:03+12:1A", "01:03:03+12:01:",
+      "01:03:03+12:01:1", "01:03:03+12:01:1A"
+    })
+    {
+      microseconds us;
+      if (sqlpp::detail::parse_time_of_day(us, tod_str))
+      {
+        std::cerr << "Parsed successfully an invalid time-of-day string " << tod_str << ", value ";
+        serialize(sqlpp::wrap_operand_t<microseconds>{us}, std::cerr);
+        std::cerr << std::endl;
+        throw std::runtime_error{"Parse error"};
+      }
+    }
+  }
+
+  void test_valid_timestamp()
+  {
+    using namespace sqlpp::chrono;
+    using namespace date;
+    using namespace std::chrono;
+
+    for (const auto& timestamp_pair : std::vector<std::pair<const char*, microsecond_point>>{
+      // Minimum and maximum timestamps
+      {"0001-01-01 00:00:00", sys_days{year{1}/1/1}}, {"9999-12-31 23:59:59.999999", sys_days{year{9999}/12/31} + hours{23} + minutes{59} + seconds{59} + microseconds{999999}},
+      // Timestamp with time zone
+      {"1234-03-25 23:17:08.479210+10:17:29", sys_days{year{1234}/3/25} + hours{23} + minutes{17} + seconds{8} + microseconds{479210} - (hours{10} + minutes{17} + seconds{29})}
+    })
+    {
+      microsecond_point tp;
+      if (sqlpp::detail::parse_timestamp(tp, timestamp_pair.first) == false)
+      {
+        std::cerr << "Could not parse a valid timestamp string: " << timestamp_pair.first << std::endl;
+        throw std::runtime_error{"Parse error"};
+      }
+      require_equal(__LINE__, tp, timestamp_pair.second);
+    }
+  }
+
+  void test_invalid_timestamp()
+  {
+    using namespace sqlpp::chrono;
+
+    for (const auto& timestamp_str : std::vector<const char*>{
+      // Generic string
+      "", "B", ")-#\\",
+      // Invalid date
+      "197%-03-17 10:32:09",
+      // Invalid time of day
+      "2020-02-18 22:2:28"
+      // Invalid time zone
+      "1924-02-28 18:35:36+1"
+      // Leading space
+      " 2030-17-01 15:20:30",
+      // Trailing space
+      "2030-17-01 15:20:30 "
+    })
+    {
+      microsecond_point tp;
+      if (sqlpp::detail::parse_timestamp(tp, timestamp_str))
+      {
+        std::cerr << "Parsed successfully an invalid timestamp string " << timestamp_str << ", value ";
+        serialize(sqlpp::wrap_operand_t<microsecond_point>{tp}, std::cerr);
+        std::cerr << std::endl;
+        throw std::runtime_error{"Parse error"};
+      }
+    }
+  }
+
+  void test_valid_date_or_timestamp()
+  {
+    using namespace sqlpp::chrono;
+    using namespace date;
+    using namespace std::chrono;
+
+    for (const auto& timestamp_pair : std::vector<std::pair<const char*, microsecond_point>>{
+      // Valid date
+      {"1998-02-03", sys_days{year{1998}/2/3}},
+      // Valid timestamp
+      {"2015-07-08 06:32:45.872+23:14:39", sys_days{year{2015}/7/8} + hours{6} + minutes{32} + seconds{45} + microseconds{872000} - (hours{23} + minutes{14} + seconds{39})}
+    })
+    {
+      microsecond_point tp;
+      if (sqlpp::detail::parse_date_or_timestamp(tp, timestamp_pair.first) == false)
+      {
+        std::cerr << "Could not parse a valid date or timestamp string: " << timestamp_pair.first << std::endl;
+        throw std::runtime_error{"Parse error"};
+      }
+      require_equal(__LINE__, tp, timestamp_pair.second);
+    }
+  }
+
+  void test_invalid_date_or_timestamp()
+  {
+    using namespace sqlpp::chrono;
+
+    for (const auto& timestamp_str : std::vector<const char*>{
+      // Generic string
+      "", "C", "/=",
+      // Invalid dates
+      "A123-01-02", "1980-E-04", "1981-09-",
+      // Invalid timestamps
+      "2023-12-31 1:02:03", "2024-03-04 05::06",
+      // Invalid time zone
+      "1930-03-18 17:30:31+01:",
+      // Leading space
+      " 1930-03-18 17:30:31+01",
+      // Trailing space
+      "1930-03-18 17:30:31+01 "
+    })
+    {
+      microsecond_point tp;
+      if (sqlpp::detail::parse_date_or_timestamp(tp, timestamp_str))
+      {
+        std::cerr << "Parsed successfully an invalid date or timestamp string " << timestamp_str << ", value ";
+        serialize(sqlpp::wrap_operand_t<microsecond_point>{tp}, std::cerr);
+        std::cerr << std::endl;
+        throw std::runtime_error{"Parse error"};
+      }
+    }
+  }
+}
+
+int DateTimeParser(int, char*[])
+{
+  test_valid_dates();
+  test_invalid_dates();
+  test_valid_time_of_day();
+  test_invalid_time_of_day();
+  test_valid_timestamp();
+  test_invalid_timestamp();
+  test_valid_date_or_timestamp();
+  test_invalid_date_or_timestamp();
+  return 0;
+}