//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

// UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: no-filesystem, no-localization, no-tzdb

// XFAIL: libcpp-has-no-experimental-tzdb
// XFAIL: availability-tzdb-missing

// <chrono>

// Tests the IANA database rules parsing and operations.
// This is not part of the public tzdb interface.
// The test uses private implementation headers.
// ADDITIONAL_COMPILE_FLAGS: -I %{libcxx-dir}/src/experimental/include

#include <chrono>
#include <fstream>
#include <string>
#include <string_view>
#include <variant>

#include "assert_macros.h"
#include "concat_macros.h"
#include "filesystem_test_helper.h"
#include "test_tzdb.h"

// headers in the dylib
#include "tzdb/types_private.h"
#include "tzdb/tzdb_private.h"

scoped_test_env env;
[[maybe_unused]] const std::filesystem::path dir = env.create_dir("zoneinfo");
const std::filesystem::path file                 = env.create_file("zoneinfo/tzdata.zi");

std::string_view std::chrono::__libcpp_tzdb_directory() {
  static std::string result = dir.string();
  return result;
}

static void write(std::string_view input) {
  static int version = 0;

  std::ofstream f{file};
  f << "# version " << version++ << '\n';
  f.write(input.data(), input.size());
}

struct parse_result {
  explicit parse_result(std::string_view input) {
    write(input);
    std::chrono::tzdb tzdb; // result not needed for the tests.
    std::chrono::__init_tzdb(tzdb, rules);
  }
  std::chrono::__tz::__rules_storage_type rules;
};

static void test_exception(std::string_view input, [[maybe_unused]] std::string_view what) {
  write(input);

  TEST_VALIDATE_EXCEPTION(
      std::runtime_error,
      [&]([[maybe_unused]] const std::runtime_error& e) {
        TEST_LIBCPP_REQUIRE(
            e.what() == what,
            TEST_WRITE_CONCATENATED("\nExpected exception ", what, "\nActual exception   ", e.what(), '\n'));
      },
      TEST_IGNORE_NODISCARD std::chrono::reload_tzdb());
}

static void test_invalid() {
  test_exception("R", "corrupt tzdb: expected whitespace");

  test_exception("R ", "corrupt tzdb: expected a string");

  test_exception("R r", "corrupt tzdb: expected whitespace");

  test_exception("R r x", "corrupt tzdb: expected a digit");
  test_exception("R r +", "corrupt tzdb: expected a digit");
  test_exception("R r mx", "corrupt tzdb year: expected 'min' or 'max'");
  test_exception("R r -32768", "corrupt tzdb year: year is less than the minimum");
  test_exception("R r 32768", "corrupt tzdb year: year is greater than the maximum");

  test_exception("R r mix", "corrupt tzdb: expected whitespace");
  test_exception("R r 0", "corrupt tzdb: expected whitespace");

  test_exception("R r 0 x", "corrupt tzdb: expected a digit");
  test_exception("R r 0 +", "corrupt tzdb: expected a digit");
  test_exception("R r 0 mx", "corrupt tzdb year: expected 'min' or 'max'");

  test_exception("R r 0 mix", "corrupt tzdb: expected whitespace");
  test_exception("R r 0 1", "corrupt tzdb: expected whitespace");

  test_exception("R r 0 1 X", "corrupt tzdb: expected character '-'");

  test_exception("R r 0 1 -", "corrupt tzdb: expected whitespace");

  test_exception("R r 0 1 - j", "corrupt tzdb month: invalid name");

  test_exception("R r 0 1 - Ja", "corrupt tzdb: expected whitespace");

  test_exception("R r 0 1 - Ja +", "corrupt tzdb weekday: invalid name");
  test_exception("R r 0 1 - Ja 32", "corrupt tzdb day: value too large");
  test_exception("R r 0 1 - Ja l", "corrupt tzdb: expected string 'last'");
  test_exception("R r 0 1 - Ja last", "corrupt tzdb weekday: invalid name");
  test_exception("R r 0 1 - Ja lastS", "corrupt tzdb weekday: invalid name");
  test_exception("R r 0 1 - Ja S", "corrupt tzdb weekday: invalid name");
  test_exception("R r 0 1 - Ja Su", "corrupt tzdb on: expected '>=' or '<='");
  test_exception("R r 0 1 - Ja Su>", "corrupt tzdb: expected character '='");
  test_exception("R r 0 1 - Ja Su<", "corrupt tzdb: expected character '='");
  test_exception("R r 0 1 - Ja Su>=+", "corrupt tzdb: expected a non-zero digit");
  test_exception("R r 0 1 - Ja Su>=0", "corrupt tzdb: expected a non-zero digit");
  test_exception("R r 0 1 - Ja Su>=32", "corrupt tzdb day: value too large");

  test_exception("R r 0 1 - Ja Su>=31", "corrupt tzdb: expected whitespace");

  test_exception("R r 0 1 - Ja Su>=31 ", "corrupt tzdb: expected a digit");
  test_exception("R r 0 1 - Ja Su>=31 +", "corrupt tzdb: expected a digit");

  test_exception("R r 0 1 - Ja Su>=31 1", "corrupt tzdb: expected whitespace");
  test_exception("R r 0 1 - Ja Su>=31 1a", "corrupt tzdb: expected whitespace");

  test_exception("R r 0 1 - Ja Su>=31 1w 2", "corrupt tzdb: expected whitespace");
  test_exception("R r 0 1 - Ja Su>=31 1w 2a", "corrupt tzdb: expected whitespace");

  test_exception("R r 0 1 - Ja Su>=31 1w 2s", "corrupt tzdb: expected whitespace");
  test_exception("R r 0 1 - Ja Su>=31 1w 2s ", "corrupt tzdb: expected a string");
}

static void test_name() {
  parse_result result{
      R"(
R z 0 1 - Ja Su>=31 1w 2s -
rULE z 0 1 - Ja Su>=31 1w 2s -
RuLe z 0 1 - Ja Su>=31 1w 2s -
R a 0 1 - Ja Su>=31 1w 2s -
R a 0 1 - Ja Su>=31 1w 2s -
)"};

  assert(result.rules.size() == 2);
  assert(result.rules[0].first == "a");
  assert(result.rules[0].second.size() == 2);
  assert(result.rules[1].first == "z");
  assert(result.rules[1].second.size() == 3);
}

static void test_from() {
  parse_result result{
      R"(
# min abbreviations
R a M 1 - Ja Su>=31 1w 2s -
R a mI 1 - Ja Su>=31 1w 2s -
R a mIN 1 - Ja Su>=31 1w 2s -

# max abbrviations
R a MA 1 - Ja Su>=31 1w 2s -
R a mAx 1 - Ja Su>=31 1w 2s -

R a -1000 1 - Ja Su>=31 1w 2s -
R a -100 1 - Ja Su>=31 1w 2s -
R a 0000 1 - Ja Su>=31 1w 2s -
R a 100 1 - Ja Su>=31 1w 2s -
R a 1000 1 - Ja Su>=31 1w 2s -
)"};

  assert(result.rules.size() == 1);
  assert(result.rules[0].second.size() == 10);

  assert(result.rules[0].second[0].__from == std::chrono::year::min());
  assert(result.rules[0].second[1].__from == std::chrono::year::min());
  assert(result.rules[0].second[2].__from == std::chrono::year::min());

  assert(result.rules[0].second[3].__from == std::chrono::year::max());
  assert(result.rules[0].second[4].__from == std::chrono::year::max());

  assert(result.rules[0].second[5].__from == std::chrono::year(-1000));
  assert(result.rules[0].second[6].__from == std::chrono::year(-100));
  assert(result.rules[0].second[7].__from == std::chrono::year(0));
  assert(result.rules[0].second[8].__from == std::chrono::year(100));
  assert(result.rules[0].second[9].__from == std::chrono::year(1000));
}

static void test_to() {
  parse_result result{
      R"(
# min abbreviations
R a 0 m - Ja Su>=31 1w 2s -
R a 0 mi - Ja Su>=31 1w 2s -
R a 0 min - Ja Su>=31 1w 2s -

# max abbrviations
R a 0 ma - Ja Su>=31 1w 2s -
R a 0 max - Ja Su>=31 1w 2s -

R a 0 -1000 - Ja Su>=31 1w 2s -
R a 0 -100 - Ja Su>=31 1w 2s -
R a 0 0000 - Ja Su>=31 1w 2s -
R a 0 100 - Ja Su>=31 1w 2s -
R a 0 1000 - Ja Su>=31 1w 2s -

# only abbreviations
R a m O - Ja Su>=31 1w 2s -
R a ma oN - Ja Su>=31 1w 2s -
R a -100 onL - Ja Su>=31 1w 2s -
R a 100 oNlY - Ja Su>=31 1w 2s -
)"};

  assert(result.rules.size() == 1);
  assert(result.rules[0].second.size() == 14);

  assert(result.rules[0].second[0].__to == std::chrono::year::min());
  assert(result.rules[0].second[1].__to == std::chrono::year::min());
  assert(result.rules[0].second[2].__to == std::chrono::year::min());

  assert(result.rules[0].second[3].__to == std::chrono::year::max());
  assert(result.rules[0].second[4].__to == std::chrono::year::max());

  assert(result.rules[0].second[5].__to == std::chrono::year(-1000));
  assert(result.rules[0].second[6].__to == std::chrono::year(-100));
  assert(result.rules[0].second[7].__to == std::chrono::year(0));
  assert(result.rules[0].second[8].__to == std::chrono::year(100));
  assert(result.rules[0].second[9].__to == std::chrono::year(1000));

  assert(result.rules[0].second[10].__to == std::chrono::year::min());
  assert(result.rules[0].second[11].__to == std::chrono::year::max());
  assert(result.rules[0].second[12].__to == std::chrono::year(-100));
  assert(result.rules[0].second[13].__to == std::chrono::year(100));
}

static void test_in() {
  parse_result result{
      R"(
# All tests in alphabetic order to validate shortest unique abbreviation

# Shortest abbreviation valid
R s 0 1 - ap Su>=31 1w 2s -
R s 0 1 - au Su>=31 1w 2s -
R s 0 1 - d Su>=31 1w 2s -
R s 0 1 - f Su>=31 1w 2s -
R s 0 1 - ja Su>=31 1w 2s -
R s 0 1 - jul Su>=31 1w 2s -
R s 0 1 - jun Su>=31 1w 2s -
R s 0 1 - May Su>=31 1w 2s -
R s 0 1 - mar Su>=31 1w 2s -
R s 0 1 - n Su>=31 1w 2s -
R s 0 1 - o Su>=31 1w 2s -
R s 0 1 - s Su>=31 1w 2s -

# 3 letter abbreviation
R a 0 1 - APR Su>=31 1w 2s -
R a 0 1 - AUG Su>=31 1w 2s -
R a 0 1 - DEC Su>=31 1w 2s -
R a 0 1 - FEB Su>=31 1w 2s -
R a 0 1 - JAN Su>=31 1w 2s -
R a 0 1 - JUL Su>=31 1w 2s -
R a 0 1 - JUN Su>=31 1w 2s -
R a 0 1 - MAY Su>=31 1w 2s -
R a 0 1 - MAR Su>=31 1w 2s -
R a 0 1 - NOV Su>=31 1w 2s -
R a 0 1 - OCT Su>=31 1w 2s -
R a 0 1 - SEP Su>=31 1w 2s -

# Full names
R f 0 1 - ApRiL Su>=31 1w 2s -
R f 0 1 - AuGuSt Su>=31 1w 2s -
R f 0 1 - DeCeMber Su>=31 1w 2s -
R f 0 1 - FeBrUary Su>=31 1w 2s -
R f 0 1 - JaNuAry Su>=31 1w 2s -
R f 0 1 - JuLy Su>=31 1w 2s -
R f 0 1 - JuNe Su>=31 1w 2s -
R f 0 1 - MaY Su>=31 1w 2s -
R f 0 1 - MaRch Su>=31 1w 2s -
R f 0 1 - NoVemBeR Su>=31 1w 2s -
R f 0 1 - OcTobEr Su>=31 1w 2s -
R f 0 1 - SePteMbEr Su>=31 1w 2s -
)"};

  assert(result.rules.size() == 3);
  for (std::size_t i = 0; i < result.rules.size(); ++i) {
    assert(result.rules[i].second.size() == 12);

    assert(result.rules[i].second[0].__in == std::chrono::April);
    assert(result.rules[i].second[1].__in == std::chrono::August);
    assert(result.rules[i].second[2].__in == std::chrono::December);
    assert(result.rules[i].second[3].__in == std::chrono::February);
    assert(result.rules[i].second[4].__in == std::chrono::January);
    assert(result.rules[i].second[5].__in == std::chrono::July);
    assert(result.rules[i].second[6].__in == std::chrono::June);
    assert(result.rules[i].second[7].__in == std::chrono::May);
    assert(result.rules[i].second[8].__in == std::chrono::March);
    assert(result.rules[i].second[9].__in == std::chrono::November);
    assert(result.rules[i].second[10].__in == std::chrono::October);
    assert(result.rules[i].second[11].__in == std::chrono::September);
  }
};

static void test_on_day() {
  parse_result result{
      R"(
# The parser does not validate the day as valid day of month
R a 0 1 - Fe 1 1w 2s -
R a 0 1 - Fe 10 1w 2s -
R a 0 1 - Fe 20 1w 2s -
R a 0 1 - Fe 30 1w 2s -
R a 0 1 - Fe 31 1w 2s -
)"};

  assert(result.rules.size() == 1);
  assert(result.rules[0].second.size() == 5);
  assert(std::get<std::chrono::day>(result.rules[0].second[0].__on) == std::chrono::day(1));
  assert(std::get<std::chrono::day>(result.rules[0].second[1].__on) == std::chrono::day(10));
  assert(std::get<std::chrono::day>(result.rules[0].second[2].__on) == std::chrono::day(20));
  assert(std::get<std::chrono::day>(result.rules[0].second[3].__on) == std::chrono::day(30));
  assert(std::get<std::chrono::day>(result.rules[0].second[4].__on) == std::chrono::day(31));
}

static void test_on_last() {
  parse_result result{
      R"(
# All tests in alphabetic order to validate shortest unique abbreviation

# Shortest abbreviation valid
R s 0 1 - Ja lastF 1w 2s -
R s 0 1 - Ja lastM 1w 2s -
R s 0 1 - Ja lastSa 1w 2s -
R s 0 1 - Ja lastSu 1w 2s -
R s 0 1 - Ja lastTh 1w 2s -
R s 0 1 - Ja lastTu 1w 2s -
R s 0 1 - Ja lastW 1w 2s -

# 3 letter abbreviation
R a 0 1 - Ja lastFri 1w 2s -
R a 0 1 - Ja lastMon 1w 2s -
R a 0 1 - Ja lastSat 1w 2s -
R a 0 1 - Ja lastSun 1w 2s -
R a 0 1 - Ja lastThu 1w 2s -
R a 0 1 - Ja lastTue 1w 2s -
R a 0 1 - Ja lastWed 1w 2s -

# Full names
R f 0 1 - Ja lastFriday 1w 2s -
R f 0 1 - Ja lastMonday 1w 2s -
R f 0 1 - Ja lastSaturday 1w 2s -
R f 0 1 - Ja lastSunday 1w 2s -
R f 0 1 - Ja lastThursday 1w 2s -
R f 0 1 - Ja lastTuesday 1w 2s -
R f 0 1 - Ja lastWednesday 1w 2s -
)"};

  assert(result.rules.size() == 3);
  for (std::size_t i = 0; i < result.rules.size(); ++i) {
    assert(result.rules[i].second.size() == 7);

    assert(std::get<std::chrono::weekday_last>(result.rules[i].second[0].__on) ==
           std::chrono::weekday_last(std::chrono::Friday));
    assert(std::get<std::chrono::weekday_last>(result.rules[i].second[1].__on) ==
           std::chrono::weekday_last(std::chrono::Monday));
    assert(std::get<std::chrono::weekday_last>(result.rules[i].second[2].__on) ==
           std::chrono::weekday_last(std::chrono::Saturday));
    assert(std::get<std::chrono::weekday_last>(result.rules[i].second[3].__on) ==
           std::chrono::weekday_last(std::chrono::Sunday));
    assert(std::get<std::chrono::weekday_last>(result.rules[i].second[4].__on) ==
           std::chrono::weekday_last(std::chrono::Thursday));
    assert(std::get<std::chrono::weekday_last>(result.rules[i].second[5].__on) ==
           std::chrono::weekday_last(std::chrono::Tuesday));
    assert(std::get<std::chrono::weekday_last>(result.rules[i].second[6].__on) ==
           std::chrono::weekday_last(std::chrono::Wednesday));
  }
}

static void test_on_constrain() {
  parse_result result{
      R"(
# Shortest abbreviation valid
R s 0 1 - Ja F>=1 1w 2s -
R s 0 1 - Ja M<=1 1w 2s -
R s 0 1 - Ja Sa>=31 1w 2s -
R s 0 1 - Ja Su<=31 1w 2s -
R s 0 1 - Ja Th>=10 1w 2s -
R s 0 1 - Ja Tu<=20 1w 2s -
R s 0 1 - Ja W>=30 1w 2s -

# 3 letter abbreviation
R a 0 1 - Ja Fri>=1 1w 2s -
R a 0 1 - Ja Mon<=1 1w 2s -
R a 0 1 - Ja Sat>=31 1w 2s -
R a 0 1 - Ja Sun<=31 1w 2s -
R a 0 1 - Ja Thu>=10 1w 2s -
R a 0 1 - Ja Tue<=20 1w 2s -
R a 0 1 - Ja Wed>=30 1w 2s -

# Full names
R f 0 1 - Ja Friday>=1 1w 2s -
R f 0 1 - Ja Monday<=1 1w 2s -
R f 0 1 - Ja Saturday>=31 1w 2s -
R f 0 1 - Ja Sunday<=31 1w 2s -
R f 0 1 - Ja Thursday>=10 1w 2s -
R f 0 1 - Ja Tuesday<=20 1w 2s -
R f 0 1 - Ja Wednesday>=30 1w 2s -

)"};

  std::chrono::__tz::__constrained_weekday r;
  assert(result.rules.size() == 3);
  for (std::size_t i = 0; i < result.rules.size(); ++i) {
    assert(result.rules[i].second.size() == 7);

    r = std::get<std::chrono::__tz::__constrained_weekday>(result.rules[i].second[0].__on);
    assert(r.__weekday == std::chrono::Friday);
    assert(r.__comparison == std::chrono::__tz::__constrained_weekday::__ge);
    assert(r.__day == std::chrono::day(1));

    r = std::get<std::chrono::__tz::__constrained_weekday>(result.rules[i].second[1].__on);
    assert(r.__weekday == std::chrono::Monday);
    assert(r.__comparison == std::chrono::__tz::__constrained_weekday::__le);
    assert(r.__day == std::chrono::day(1));

    r = std::get<std::chrono::__tz::__constrained_weekday>(result.rules[i].second[2].__on);
    assert(r.__weekday == std::chrono::Saturday);
    assert(r.__comparison == std::chrono::__tz::__constrained_weekday::__ge);
    assert(r.__day == std::chrono::day(31));

    r = std::get<std::chrono::__tz::__constrained_weekday>(result.rules[i].second[3].__on);
    assert(r.__weekday == std::chrono::Sunday);
    assert(r.__comparison == std::chrono::__tz::__constrained_weekday::__le);
    assert(r.__day == std::chrono::day(31));

    r = std::get<std::chrono::__tz::__constrained_weekday>(result.rules[i].second[4].__on);
    assert(r.__weekday == std::chrono::Thursday);
    assert(r.__comparison == std::chrono::__tz::__constrained_weekday::__ge);
    assert(r.__day == std::chrono::day(10));

    r = std::get<std::chrono::__tz::__constrained_weekday>(result.rules[i].second[5].__on);
    assert(r.__weekday == std::chrono::Tuesday);
    assert(r.__comparison == std::chrono::__tz::__constrained_weekday::__le);
    assert(r.__day == std::chrono::day(20));

    r = std::get<std::chrono::__tz::__constrained_weekday>(result.rules[i].second[6].__on);
    assert(r.__weekday == std::chrono::Wednesday);
    assert(r.__comparison == std::chrono::__tz::__constrained_weekday::__ge);
    assert(r.__day == std::chrono::day(30));
  }
}

static void test_on() {
  test_on_day();
  test_on_last();
  test_on_constrain();
}

static void test_at() {
  parse_result result{
      R"(
# Based on the examples in the man page.
# Note the input is not expected to have fractional seconds, they are truncated.
R a 0 1 - Ja Su>=31 2w 2s -
R a 0 1 - Ja Su>=31 2:00s 2s -
R a 0 1 - Ja Su>=31 01:28:14u 2s -
R a 0 1 - Ja Su>=31 00:19:32.10g 2s -
R a 0 1 - Ja Su>=31 12:00z 2s -
R a 0 1 - Ja Su>=31 15:00 2s -
R a 0 1 - Ja Su>=31 24:00 2s -
R a 0 1 - Ja Su>=31 260:00 2s -
R a 0 1 - Ja Su>=31 -2:30 2s -
R a 0 1 - Ja Su>=31 - 2s -
)"};

  assert(result.rules.size() == 1);
  assert(result.rules[0].second.size() == 10);

  assert(result.rules[0].second[0].__at.__time == std::chrono::hours(2));
  assert(result.rules[0].second[0].__at.__clock == std::chrono::__tz::__clock::__local);

  assert(result.rules[0].second[1].__at.__time == std::chrono::hours(2));
  assert(result.rules[0].second[1].__at.__clock == std::chrono::__tz::__clock::__standard);

  assert(result.rules[0].second[2].__at.__time ==
         std::chrono::hours(1) + std::chrono::minutes(28) + std::chrono::seconds(14));
  assert(result.rules[0].second[2].__at.__clock == std::chrono::__tz::__clock::__universal);

  assert(result.rules[0].second[3].__at.__time == std::chrono::minutes(19) + std::chrono::seconds(32));
  assert(result.rules[0].second[3].__at.__clock == std::chrono::__tz::__clock::__universal);

  assert(result.rules[0].second[4].__at.__time == std::chrono::hours(12));
  assert(result.rules[0].second[4].__at.__clock == std::chrono::__tz::__clock::__universal);

  assert(result.rules[0].second[5].__at.__time == std::chrono::hours(15));
  assert(result.rules[0].second[5].__at.__clock == std::chrono::__tz::__clock::__local);

  assert(result.rules[0].second[6].__at.__time == std::chrono::hours(24));
  assert(result.rules[0].second[6].__at.__clock == std::chrono::__tz::__clock::__local);

  assert(result.rules[0].second[7].__at.__time == std::chrono::hours(260));
  assert(result.rules[0].second[7].__at.__clock == std::chrono::__tz::__clock::__local);

  assert(result.rules[0].second[8].__at.__time == -(std::chrono::hours(2) + std::chrono::minutes(30)));
  assert(result.rules[0].second[8].__at.__clock == std::chrono::__tz::__clock::__local);

  assert(result.rules[0].second[9].__at.__time == std::chrono::hours(0)); // The man page expresses it in hours
  assert(result.rules[0].second[9].__at.__clock == std::chrono::__tz::__clock::__local);
}

static void test_save() {
  parse_result result{
      R"(
R a 0 1 - Ja Su>=31 1w 2d -
R a 0 1 - Ja Su>=31 1w 2:00s -
R a 0 1 - Ja Su>=31 1w 0 -
R a 0 1 - Ja Su>=31 1w 0:00:01 -
R a 0 1 - Ja Su>=31 1w -0:00:01 -
)"};

  assert(result.rules.size() == 1);
  assert(result.rules[0].second.size() == 5);

  assert(result.rules[0].second[0].__save.__time == std::chrono::hours(2));
  assert(result.rules[0].second[0].__save.__is_dst == true);

  assert(result.rules[0].second[1].__save.__time == std::chrono::hours(2));
  assert(result.rules[0].second[1].__save.__is_dst == false);

  assert(result.rules[0].second[2].__save.__time == std::chrono::hours(0));
  assert(result.rules[0].second[2].__save.__is_dst == false);

  assert(result.rules[0].second[3].__save.__time == std::chrono::seconds(1));
  assert(result.rules[0].second[3].__save.__is_dst == true);

  assert(result.rules[0].second[4].__save.__time == -std::chrono::seconds(1));
  assert(result.rules[0].second[4].__save.__is_dst == true);
}

static void test_letter() {
  parse_result result{
      R"(
R a 0 1 - Ja Su>=31 1w 2s -
R a 0 1 - Ja Su>=31 1w 2s a
R a 0 1 - Ja Su>=31 1w 2s abc
)"};

  assert(result.rules.size() == 1);
  assert(result.rules[0].second.size() == 3);

  assert(result.rules[0].second[0].__letters == "");
  assert(result.rules[0].second[1].__letters == "a");
  assert(result.rules[0].second[2].__letters == "abc");
}

static void test_mixed_order() {
  // This is a part of the real database. The interesting part is that the
  // rules NZ and Chatham are interleaved. Make sure the parse algorithm
  // handles this correctly.
  parse_result result{
      R"(
# Since 1957 Chatham has been 45 minutes ahead of NZ, but until 2018a
# there was no documented single notation for the date and time of this
# transition.  Duplicate the Rule lines for now, to give the 2018a change
# time to percolate out.
Rule NZ  1974    only    -   Nov Sun>=1  2:00s   1:00    D
Rule Chatham 1974    only    -   Nov Sun>=1  2:45s   1:00    -
Rule NZ  1975    only    -   Feb lastSun 2:00s   0   S
Rule Chatham 1975    only    -   Feb lastSun 2:45s   0   -
Rule NZ  1975    1988    -   Oct lastSun 2:00s   1:00    D
Rule Chatham 1975    1988    -   Oct lastSun 2:45s   1:00    -
)"};

  assert(result.rules.size() == 2);
  assert(result.rules[0].second.size() == 3);
  assert(result.rules[1].second.size() == 3);
}

int main(int, const char**) {
  test_invalid();
  test_name();
  test_from();
  test_to();
  test_in();
  test_on();
  test_at();
  test_save();
  test_letter();
  test_mixed_order();

  return 0;
}
