internal ZoneRuleSet(List<ZoneRecurrence> rules, Offset standardOffset, int upperYear, ZoneYearOffset upperYearOffset)
 {
     this.rules = rules;
     this.StandardOffset = standardOffset;
     this.upperYear = upperYear;
     this.upperYearOffset = upperYearOffset;
 }

 public void GetOccurrenceForYear_Defaults_Epoch()
 {
     var offset = new ZoneYearOffset(TransitionMode.Utc, 1, 1, 0, true, LocalTime.Midnight);
     var actual = offset.GetOccurrenceForYear(1970);
     var expected = new LocalDateTime(1970, 1, 1, 0, 0).ToLocalInstant();
     Assert.AreEqual(expected, actual);
 }

 public void Next_FirstYear()
 {
     var januaryFirstMidnight = new ZoneYearOffset(TransitionMode.Utc, 1, 1, 0, true, Offset.Zero);
     var recurrence = new ZoneRecurrence("bob", Offset.Zero, januaryFirstMidnight, 1970, 1972);
     Transition? actual = recurrence.Next(Instant.UnixEpoch, Offset.Zero, Offset.Zero);
     Transition? expected = new Transition(new Instant(Instant.UnixEpoch.Ticks + (1 * TicksPerStandardYear)), Offset.Zero, Offset.Zero);
     Assert.AreEqual(expected, actual);
 }

 public void PreviousOrSame_LastYear()
 {
     var januaryFirstMidnight = new ZoneYearOffset(TransitionMode.Utc, 1, 1, 0, true, LocalTime.Midnight);
     var recurrence = new ZoneRecurrence("bob", Offset.Zero, januaryFirstMidnight, 1970, 1972);
     Transition? actual = recurrence.PreviousOrSame(Instant.FromUtc(1971, 1, 1, 0, 0) - Duration.Epsilon, Offset.Zero, Offset.Zero);
     Transition? expected = new Transition(NodaConstants.UnixEpoch, Offset.Zero);
     Assert.AreEqual(expected, actual);
 }

 public void WriteRead()
 {
     var yearOffset = new ZoneYearOffset(TransitionMode.Utc, 10, 31, (int)IsoDayOfWeek.Wednesday, true, Offset.Zero);
     var recurrence = new ZoneRecurrence("bob", Offset.Zero, yearOffset, 1971, 2009);
     var actual = new ZoneRule(recurrence, "D");
     var expected = new ZoneRule(recurrence, "D");
     Assert.AreEqual(expected, actual);
 }

 public void Next_BeforeFirstYear()
 {
     var januaryFirstMidnight = new ZoneYearOffset(TransitionMode.Utc, 1, 1, 0, true, LocalTime.Midnight);
     var recurrence = new ZoneRecurrence("bob", Offset.Zero, januaryFirstMidnight, 1970, 1972);
     Transition? actual = recurrence.Next(Instant.MinValue, Offset.Zero, Offset.Zero);
     Transition? expected = new Transition(NodaConstants.UnixEpoch, Offset.Zero);
     Assert.AreEqual(expected, actual);
 }

 public void PreviousOrSame_AfterLastYear()
 {
     var januaryFirstMidnight = new ZoneYearOffset(TransitionMode.Utc, 1, 1, 0, true, LocalTime.Midnight);
     var recurrence = new ZoneRecurrence("bob", Offset.Zero, januaryFirstMidnight, 1970, 1972);
     Transition? actual = recurrence.PreviousOrSame(Instant.MaxValue, Offset.Zero, Offset.Zero);
     Transition? expected = new Transition(Instant.FromUtc(1972, 1, 1, 0, 0), Offset.Zero);
     Assert.AreEqual(expected, actual);
 }

 public void ParseDateTimeOfYear_missingAt_validForZone()
 {
     const string text = "Mar lastSun";
     var tokens = Tokens.Tokenize(text);
     var actual = Parser.ParseDateTimeOfYear(tokens, false);
     var expected = new ZoneYearOffset(TransitionMode.Wall, 3, -1, (int) IsoDayOfWeek.Sunday, false, LocalTime.Midnight);
     Assert.AreEqual(expected, actual);
 }

 public void Equality()
 {
     var yearOffset = new ZoneYearOffset(TransitionMode.Utc, 10, 31, (int)IsoDayOfWeek.Wednesday, true, LocalTime.Midnight);
     var recurrence = new ZoneRecurrence("bob", Offset.Zero, yearOffset, 1971, 2009);
     var actual = new RuleLine(recurrence, "D", null);
     var expected = new RuleLine(recurrence, "D", null);
     Assert.AreEqual(expected, actual);
 }

 public void ParseDateTimeOfYear_missingOn_validForZone()
 {
     const string text = "Mar";
     var tokens = Tokens.Tokenize(text);
     var actual = Parser.ParseDateTimeOfYear(tokens, false);
     var expected = new ZoneYearOffset(TransitionMode.Wall, 3, 1, 0, false, LocalTime.Midnight);
     Assert.AreEqual(expected, actual);
 }

 public void RenameAppend()
 {
     var yearOffset = new ZoneYearOffset(TransitionMode.Utc, 10, 31, (int)IsoDayOfWeek.Wednesday, true, Offset.Zero);
     var old = new ZoneRecurrence("bob", Offset.Zero, yearOffset, 1971, 2009);
     var actual = old.RenameAppend("-Summer");
     var expected = new ZoneRecurrence("bob-Summer", Offset.Zero, yearOffset, 1971, 2009);
     Assert.AreEqual(expected, actual);
 }

 public void Next_BeyondLastYear_null()
 {
     var afterRecurrenceEnd = Instant.FromUtc(1980, 1, 1, 0, 0);
     var januaryFirstMidnight = new ZoneYearOffset(TransitionMode.Utc, 1, 1, 0, true, LocalTime.Midnight);
     var recurrence = new ZoneRecurrence("bob", Offset.Zero, januaryFirstMidnight, 1970, 1972);
     Transition? actual = recurrence.Next(afterRecurrenceEnd, Offset.Zero, Offset.Zero);
     Transition? expected = null;
     Assert.AreEqual(expected, actual);
 }

        public void FormatName_Slash_Daylight()
        {
            var yearOffset = new ZoneYearOffset(TransitionMode.Utc, 10, 31, (int) IsoDayOfWeek.Wednesday, true, LocalTime.Midnight);
            var recurrence = new ZoneRecurrence("ignored", Offset.FromHours(1), yearOffset, 1971, 2009);
            var rule = new RuleLine(recurrence, "!", null);
            var zone = GetZone("X/Y", Offset.FromHours(1));

            var zoneRecurrence = rule.GetRecurrences(zone).Single();
            Assert.AreEqual("Y", zoneRecurrence.Name);
        }

        public void FormatName_PercentS()
        {
            // Note that the offset is irrelevant here - the "daylight saving indicator" is replaced either way.
            var yearOffset = new ZoneYearOffset(TransitionMode.Utc, 10, 31, (int) IsoDayOfWeek.Wednesday, true, LocalTime.Midnight);
            var recurrence = new ZoneRecurrence("ignored", Offset.Zero, yearOffset, 1971, 2009);
            var rule = new RuleLine(recurrence, "!", null);
            var zone = GetZone("X%sY", Offset.Zero);

            var zoneRecurrence = rule.GetRecurrences(zone).Single();
            Assert.AreEqual("X!Y", zoneRecurrence.Name);
        }

        public void FormatName_PercentZ()
        {
            var yearOffset = new ZoneYearOffset(TransitionMode.Utc, 10, 31, (int) IsoDayOfWeek.Wednesday, true, LocalTime.Midnight);
            var recurrence = new ZoneRecurrence("Rule", Offset.FromHoursAndMinutes(5, 30), yearOffset, 1971, 2009);
            var rule = new RuleLine(recurrence, "D", null);
            
            var zoneRecurrence = rule.GetRecurrences(GetZone("X%zY", Offset.Zero)).Single();
            Assert.AreEqual("X+0530Y", zoneRecurrence.Name);

            zoneRecurrence = rule.GetRecurrences(GetZone("X%zY", Offset.FromHoursAndMinutes(0, 30))).Single();
            Assert.AreEqual("X+06Y", zoneRecurrence.Name);

            zoneRecurrence = rule.GetRecurrences(GetZone("X%zY", Offset.FromHoursAndMinutes(-6, -30))).Single();
            Assert.AreEqual("X-01Y", zoneRecurrence.Name);
        }

 public void PreviousTwice_JanOne()
 {
     var offset = new ZoneYearOffset(TransitionMode.Utc, 1, 1, 0, true, Offset.Zero);
     var actual = offset.MakeInstant(1970, Offset.Zero, Offset.Zero);
     long baseTicks = actual.Ticks;
     actual = offset.Previous(actual, Offset.Zero, Offset.Zero);
     actual = offset.Previous(actual, Offset.Zero, Offset.Zero);
     var expected = new Instant(baseTicks - (TicksPerStandardYear + TicksPerLeapYear));
     Assert.AreEqual(expected, actual);
 }

 public void Previous_OneSecondAfterJanOne()
 {
     var offset = new ZoneYearOffset(TransitionMode.Utc, 1, 1, 0, true, Offset.Zero);
     var actual = offset.MakeInstant(1970, Offset.Zero, Offset.Zero) + Duration.One;
     actual = offset.Previous(actual, Offset.Zero, Offset.Zero);
     var expected = Instant.UnixEpoch;
     Assert.AreEqual(expected, actual);
 }

 public void NextTwice_Feb29_FourYears()
 {
     var offset = new ZoneYearOffset(TransitionMode.Utc, 2, 29, 0, true, Offset.Zero);
     var actual = offset.MakeInstant(1972, Offset.Zero, Offset.Zero);
     long baseTicks = actual.Ticks;
     actual = offset.Next(actual, Offset.Zero, Offset.Zero);
     actual = offset.Next(actual, Offset.Zero, Offset.Zero);
     var expected = new Instant(baseTicks + (2 * ((3 * TicksPerStandardYear) + TicksPerLeapYear)));
     Assert.AreEqual(expected, actual);
 }

 public void Next_OneSecondBeforeJanOne()
 {
     var offset = new ZoneYearOffset(TransitionMode.Utc, 1, 1, 0, true, Offset.Zero);
     var actual = offset.MakeInstant(1970, Offset.Zero, Offset.Zero) - Duration.One;
     actual = offset.Next(actual, Offset.Zero, Offset.Zero);
     var expected = Instant.UnixEpoch;
     Assert.AreEqual(expected, actual);
 }

 public void Next_JanOne()
 {
     var offset = new ZoneYearOffset(TransitionMode.Utc, 1, 1, 0, true, Offset.Zero);
     var actual = offset.MakeInstant(1970, Offset.Zero, Offset.Zero);
     long baseTicks = actual.Ticks;
     actual = offset.Next(actual, Offset.Zero, Offset.Zero);
     var expected = new Instant(baseTicks + (1 * TicksPerStandardYear));
     Assert.AreEqual(expected, actual);
 }