public void EraProperty()
 {
     CalendarSystem calendar = CalendarSystem.Gregorian;
     LocalDateTime startOfEra = new LocalDateTime(1, 1, 1, 0, 0, 0, calendar);
     Assert.AreEqual(Era.Common, startOfEra.Era);
     Assert.AreEqual(Era.BeforeCommon, startOfEra.PlusTicks(-1).Era);
 }
Ejemplo n.º 2
0
        public void EraProperty()
        {
            CalendarSystem calendar   = CalendarSystem.GetJulianCalendar(4);
            LocalDateTime  startOfEra = new LocalDateTime(1, 1, 1, 0, 0, 0, calendar);

            Assert.AreEqual(Era.Common, startOfEra.Era);
            Assert.AreEqual(Era.BeforeCommon, startOfEra.PlusTicks(-1).Era);
        }
Ejemplo n.º 3
0
        public void Addition_Duration()
        {
            const int  minutes      = 23;
            const int  hours        = 3;
            const int  milliseconds = 40000;
            const long seconds      = 321;
            const long nanoseconds  = 12345;
            const long ticks        = 5432112345;

            // Test all three approaches... not bothering to check a different calendar,
            // but we'll use two different offsets.
            OffsetDateTime start    = new LocalDateTime(2014, 08, 14, 6, 51).WithOffset(Offset.FromHours(1));
            Duration       duration = Duration.FromHours(8) + Duration.FromMinutes(9);
            OffsetDateTime expected = new LocalDateTime(2014, 08, 14, 15, 0).WithOffset(Offset.FromHours(1));

            Assert.AreEqual(expected, start + duration);
            Assert.AreEqual(expected, start.Plus(duration));
            Assert.AreEqual(expected, OffsetDateTime.Add(start, duration));

            Assert.AreEqual(start + Duration.FromHours(hours), start.PlusHours(hours));
            Assert.AreEqual(start + Duration.FromHours(-hours), start.PlusHours(-hours));

            Assert.AreEqual(start + Duration.FromMinutes(minutes), start.PlusMinutes(minutes));
            Assert.AreEqual(start + Duration.FromMinutes(-minutes), start.PlusMinutes(-minutes));

            Assert.AreEqual(start + Duration.FromSeconds(seconds), start.PlusSeconds(seconds));
            Assert.AreEqual(start + Duration.FromSeconds(-seconds), start.PlusSeconds(-seconds));

            Assert.AreEqual(start + Duration.FromMilliseconds(milliseconds), start.PlusMilliseconds(milliseconds));
            Assert.AreEqual(start + Duration.FromMilliseconds(-milliseconds), start.PlusMilliseconds(-milliseconds));

            Assert.AreEqual(start + Duration.FromTicks(ticks), start.PlusTicks(ticks));
            Assert.AreEqual(start + Duration.FromTicks(-ticks), start.PlusTicks(-ticks));

            Assert.AreEqual(start + Duration.FromNanoseconds(nanoseconds), start.PlusNanoseconds(nanoseconds));
            Assert.AreEqual(start + Duration.FromNanoseconds(-nanoseconds), start.PlusNanoseconds(-nanoseconds));
        }
Ejemplo n.º 4
0
        public void BoundaryLimitTest()
        {
            var list  = new List <ValueTick>();
            var date1 = new LocalDateTime(2000, 1, 1, 0, 0).InUtc().ToInstant();
            var date2 = new LocalDateTime(2000, 1, 2, 0, 0).InUtc().ToInstant();

            list.Add(new ValueTick {
                Date = date1, Value = 1
            });
            list.Add(new ValueTick {
                Date = date2, Value = 2
            });

            var result = list.InterpolateValue(date2.PlusTicks(1));

            Assert.Equal(2, result);

            result = list.InterpolateValue(date2.Plus(Duration.FromHours(7 * 24)));
            Assert.True(double.IsNaN(result)); // not enough data
        }
Ejemplo n.º 5
0
 public void PlusTicks()
 {
     SampleStartDateTime.PlusTicks(3);
 }
Ejemplo n.º 6
0
 public LocalDateTime PlusTicks() => Sample.PlusTicks(3);
 public void PlusTicks()
 {
     Sample.PlusTicks(3).Consume();
 }
Ejemplo n.º 8
0
        public void Addition_Duration()
        {
            const int minutes = 23;
            const int hours = 3;
            const int milliseconds = 40000;
            const long seconds = 321;
            const long nanoseconds = 12345;
            const long ticks = 5432112345;

            // Test all three approaches... not bothering to check a different calendar,
            // but we'll use two different offsets.
            OffsetDateTime start = new LocalDateTime(2014, 08, 14, 6, 51).WithOffset(Offset.FromHours(1));
            Duration duration = Duration.FromHours(8) + Duration.FromMinutes(9);
            OffsetDateTime expected = new LocalDateTime(2014, 08, 14, 15, 0).WithOffset(Offset.FromHours(1));
            Assert.AreEqual(expected, start + duration);
            Assert.AreEqual(expected, start.Plus(duration));
            Assert.AreEqual(expected, OffsetDateTime.Add(start, duration));

            Assert.AreEqual(start + Duration.FromHours(hours), start.PlusHours(hours));
            Assert.AreEqual(start + Duration.FromHours(-hours), start.PlusHours(-hours));

            Assert.AreEqual(start + Duration.FromMinutes(minutes), start.PlusMinutes(minutes));
            Assert.AreEqual(start + Duration.FromMinutes(-minutes), start.PlusMinutes(-minutes));

            Assert.AreEqual(start + Duration.FromSeconds(seconds), start.PlusSeconds(seconds));
            Assert.AreEqual(start + Duration.FromSeconds(-seconds), start.PlusSeconds(-seconds));

            Assert.AreEqual(start + Duration.FromMilliseconds(milliseconds), start.PlusMilliseconds(milliseconds));
            Assert.AreEqual(start + Duration.FromMilliseconds(-milliseconds), start.PlusMilliseconds(-milliseconds));

            Assert.AreEqual(start + Duration.FromTicks(ticks), start.PlusTicks(ticks));
            Assert.AreEqual(start + Duration.FromTicks(-ticks), start.PlusTicks(-ticks));

            Assert.AreEqual(start + Duration.FromNanoseconds(nanoseconds), start.PlusNanoseconds(nanoseconds));
            Assert.AreEqual(start + Duration.FromNanoseconds(-nanoseconds), start.PlusNanoseconds(-nanoseconds));
        }
 public void PlusTicks_Long()
 {
     Assert.IsTrue(NodaConstants.TicksPerStandardDay > int.MaxValue);
     LocalDateTime start = new LocalDateTime(2011, 4, 2, 12, 15, 8);
     LocalDateTime expectedForward = new LocalDateTime(2011, 4, 3, 12, 15, 8);
     LocalDateTime expectedBackward = new LocalDateTime(2011, 4, 1, 12, 15, 8);
     Assert.AreEqual(expectedForward, start.PlusTicks(NodaConstants.TicksPerStandardDay));
     Assert.AreEqual(expectedBackward, start.PlusTicks(-NodaConstants.TicksPerStandardDay));
 }
 public void PlusTicks_Simple()
 {
     LocalDateTime start = new LocalDateTime(2011, 4, 2, 12, 15, 8, 300, 7500);
     LocalDateTime expectedForward = new LocalDateTime(2011, 4, 2, 12, 15, 8, 301, 1500);
     LocalDateTime expectedBackward = new LocalDateTime(2011, 4, 2, 12, 15, 8, 300, 3500);
     Assert.AreEqual(expectedForward, start.PlusTicks(4000));
     Assert.AreEqual(expectedBackward, start.PlusTicks(-4000));
 }
Ejemplo n.º 11
0
 public LocalDateTime PlusTicks()
 {
     return(Sample.PlusTicks(3));
 }
 /// <summary>
 /// Add TimeSpan
 /// </summary>
 /// <param name="lt"></param>
 /// <param name="ts"></param>
 /// <returns></returns>
 public static LocalDateTime Add(this LocalDateTime lt, TimeSpan ts) => lt.PlusTicks(ts.Ticks);