示例#1
0
        // --------------------------------------------------------------------------------

        public static DateTimeOffset Round(this DateTimeOffset dto, DateTimeFieldEnum field)
        {
            switch (field)
            {
            case DateTimeFieldEnum.MILLISEC: {
                dto = dto.AddTicks(5000);
                return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, dto.Millisecond, dto.Offset));
            }

            case DateTimeFieldEnum.SECOND: {
                dto = dto.AddMilliseconds(500);
                return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, 0, dto.Offset));
            }

            case DateTimeFieldEnum.MINUTE: {
                dto = dto.AddSeconds(30);
                return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, 0, 0, dto.Offset));
            }

            case DateTimeFieldEnum.HOUR: {
                dto = dto.AddMinutes(30);
                return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, 0, 0, 0, dto.Offset));
            }

            case DateTimeFieldEnum.DAY:
            case DateTimeFieldEnum.DATE: {
                dto = dto.Add(TimeSpan.FromSeconds(43200));
                return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, 0, 0, 0, 0, dto.Offset));
            }

            case DateTimeFieldEnum.MONTH: {
                var stMonth = dto.Month;
                var stYear  = dto.Year;
                var stDate  = new DateTimeOffset(stYear, stMonth, 1, 0, 0, 0, 0, dto.Offset);

                var edMonth = stMonth == 12 ? 1 : stMonth + 1;
                var edYear  = stMonth == 12 ? stYear + 1 : stYear;
                var edDate  = new DateTimeOffset(edYear, edMonth, 1, 0, 0, 0, 0, dto.Offset);

                var ticksInHalfMonth = (edDate.Ticks - stDate.Ticks) / 2;

                dto = dto.AddTicks(ticksInHalfMonth);
                return(new DateTimeOffset(dto.Year, dto.Month, 1, 0, 0, 0, 0, dto.Offset));
            }

            case DateTimeFieldEnum.YEAR: {
                var stYear = dto.Year;
                var stDate = new DateTimeOffset(stYear, 1, 1, 0, 0, 0, 0, dto.Offset);
                var edDate = new DateTimeOffset(stYear + 1, 1, 1, 0, 0, 0, 0, dto.Offset);

                var ticksInHalfYear = (edDate.Ticks - stDate.Ticks) / 2;

                dto = dto.AddTicks(ticksInHalfYear);
                return(new DateTimeOffset(dto.Year, 1, 1, 0, 0, 0, 0, dto.Offset));
            }

            default:
                throw new NotSupportedException();
            }
        }
示例#2
0
        /// <summary>
        /// Rounds the given datetime by a given timespan.
        /// </summary>
        /// <param name="dateTime">The datetime to round.</param>
        /// <param name="roundBy">The time span to round by.</param>
        /// <returns>The rounded time.</returns>
        public static DateTimeOffset Round(this DateTimeOffset dateTime, TimeSpan roundBy)
        {
            long remainderTicks = dateTime.Ticks % roundBy.Ticks;

            if (remainderTicks < roundBy.Ticks / 2)
            {
                // round down
                return(dateTime.AddTicks(-remainderTicks));
            }

            // round up
            return(dateTime.AddTicks(roundBy.Ticks - remainderTicks));
        }
        /// <summary>
        /// Sets the time to the previous factor of <see cref="timeSpan"/>.
        /// </summary>
        /// <param name="value"></param>
        /// <param name="timeSpan"></param>
        /// <param name="roundUp"></param>
        /// <returns></returns>
        private static DateTimeOffset DoRound(this DateTimeOffset value, TimeSpan timeSpan, bool?roundUp)
        {
            if (timeSpan.Ticks == 0)
            {
                return(value);
            }

            var(previous, next) = value.GetDeltaTicks(timeSpan);

            return(roundUp ?? (next <= previous)
                       ? (next == 0 ? value : value.AddTicks(next))
                       : (previous == 0 ? value : value.AddTicks(-previous)));
        }
示例#4
0
 public void Compare_Test2()
 {
     var dt0 = new DateTimeOffset(1582, 10, 15, 0, 0, 0, TimeSpan.Zero);
     var arr = new []
     {
         TimeUuid.NewId(dt0.AddTicks(0x00000000007fffL)),
         TimeUuid.NewId(dt0.AddTicks(0x00ff0000000000L)),
         TimeUuid.NewId(dt0.AddTicks(0x07ff0000000000L)),
         TimeUuid.NewId(dt0.AddTicks(0x07ff0000ff0000L))
     };
     var actual = (TimeUuid[])arr.Clone();
     Array.Sort(actual);
     CollectionAssert.AreEqual(arr, actual);
 }
示例#5
0
        public void MergeTwoStreams_7()
        {
            var result = new List <string>();
            var errors = new List <Exception>();

            var start = new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.Zero);

            using (var waitHandle = new ManualResetEvent(false))
                using (var intSubject = new Subject <Timestamped <int> >())
                    using (var stringSubject = new Subject <Timestamped <string> >())
                        using (var playback = new Playback())
                        {
                            ((IPlaybackConfiguration)playback).AddInput(
                                () => stringSubject,
                                new ITypeMap <Timestamped <string> >[] { new TimestampedTypeMap <string>() });

                            ((IPlaybackConfiguration)playback).AddInput(
                                () => intSubject,
                                new ITypeMap <Timestamped <int> >[] { new TimestampedTypeMap <int>() });

                            using (playback.GetObservable <string>()
                                   .Merge(playback.GetObservable <int>().Select(i => i.ToString()), playback.Scheduler)
                                   .Subscribe(
                                       Observer.Create <string>(
                                           result.Add,
                                           errors.Add,
                                           () => waitHandle.Set())))
                            {
                                playback.Start();

                                stringSubject.OnNext(new Timestamped <string>("1", start));
                                intSubject.OnNext(new Timestamped <int>(2, start.AddTicks(1)));
                                stringSubject.OnNext(new Timestamped <string>("3", start.AddTicks(2)));
                                intSubject.OnNext(new Timestamped <int>(4, start.AddTicks(3)));

                                stringSubject.OnCompleted();
                                intSubject.OnCompleted();

                                var notTimeouted = waitHandle.WaitOne(TimeSpan.FromSeconds(1));
                                Assert.IsTrue(notTimeouted);
                            }
                        }

            Assert.AreEqual(0, errors.Count);
            Assert.AreEqual(4, result.Count);
            Assert.AreEqual("1", result[0]);
            Assert.AreEqual("2", result[1]);
            Assert.AreEqual("3", result[2]);
            Assert.AreEqual("4", result[3]);
        }
示例#6
0
        public void Compare_Test2()
        {
            var dt0 = new DateTimeOffset(1582, 10, 15, 0, 0, 0, TimeSpan.Zero);
            var arr = new []
            {
                TimeUuid.NewId(dt0.AddTicks(0x00000000007fffL)),
                TimeUuid.NewId(dt0.AddTicks(0x00ff0000000000L)),
                TimeUuid.NewId(dt0.AddTicks(0x07ff0000000000L)),
                TimeUuid.NewId(dt0.AddTicks(0x07ff0000ff0000L))
            };
            var actual = (TimeUuid[])arr.Clone();

            Array.Sort(actual);
            CollectionAssert.AreEqual(arr, actual);
        }
示例#7
0
        public static DateTimeOffset TruncateTo(this DateTimeOffset dateTimeOffset, TimeSpan span, DateTimeOffset?epoch = null)
        {
            var diff   = dateTimeOffset - (epoch ?? DefaultDateTimeOffsetEpoch);
            var excess = diff.Ticks % span.Ticks;

            return(excess == 0 ? dateTimeOffset : dateTimeOffset.AddTicks(-excess));
        }
示例#8
0
        public async Task ExpiresOnlyCorrectEntities(int entitiesToAdd, int entitiesToExpire)
        {
            for (int i = 0; i < entitiesToAdd; i++)
            {
                MockTokenGenerator
                .Setup(generator => generator.Next)
                .Returns(i.ToString());
                DateTimeOffset entityStoreTime = TestTime.AddTicks(i);
                MockTime
                .Setup(time => time.Current)
                .Returns(entityStoreTime);
                TestObject.Store(TestEntity);
            }
            DateTimeOffset expirationTime = TestTime
                                            .AddMinutes(TestExpiration)
                                            .AddTicks(entitiesToExpire);

            MockTime
            .Setup(time => time.Current)
            .Returns(expirationTime);

            await Task.Delay(TimeToWaitForSleepInMs);

            Assert.AreEqual(entitiesToAdd - entitiesToExpire, TestObject.Count);
        }
示例#9
0
        /// <summary>
        /// Converts the value of the current <see cref="PartialDateTime"/> object to a <see cref="DateTimeOffset"/> value.
        /// </summary>
        /// <param name="defaultMonth">The value to use if month component missing.</param>
        /// <param name="defaultDaySelector">A selector to get the value to use if day component is missing.</param>
        /// <param name="defaultHour">The value to use if hour component is missing.</param>
        /// <param name="defaultMinute">The value to use if minute component is missing.</param>
        /// <param name="defaultSecond">The value to use if second component is missing.</param>
        /// <param name="defaultFraction">The value to use if fraction component is missing.</param>
        /// <param name="defaultUtcOffset">The value to use if UTC offset component is missing.</param>
        /// <returns>An object that represents the date and time of the current <see cref="PartialDateTime"/> object.</returns>
        public DateTimeOffset ToDateTimeOffset(
            int defaultMonth,
            DaySelector defaultDaySelector,
            int defaultHour,
            int defaultMinute,
            int defaultSecond,
            decimal defaultFraction,
            TimeSpan defaultUtcOffset)
        {
            int month = Month ?? defaultMonth;

            var offset = new DateTimeOffset(
                Year,
                month,
                Day ?? defaultDaySelector(Year, month),
                Hour ?? defaultHour,
                Minute ?? defaultMinute,
                Second ?? defaultSecond,
                UtcOffset ?? defaultUtcOffset);

            // Add second, millisecond, and fraction.
            decimal fraction = Fraction ?? defaultFraction;

            offset = offset.AddTicks((long)(fraction * TimeSpan.TicksPerSecond));

            return(offset);
        }
示例#10
0
        private static void Dump(TimeZoneInfo zone, Options options, TextWriter writer)
        {
            writer.Write($"{zone.Id}\n");

            // This will be a bit odd using Windows time zones, as most have permanent
            // daylight saving rules... but for tz data, it should be okay.
            var initial = new DateTimeOffset(2, 1, 1, 0, 0, 0, 0, TimeSpan.Zero);
            var initialOffset = zone.GetUtcOffset(initial);
            var initialDaylight = zone.IsDaylightSavingTime(initial);
            writer.Write("Initially:           {0} {1} {2}\n",
                (initialOffset.Ticks >= 0 ? "+" : "-") + initialOffset.ToString("hh':'mm':'ss", CultureInfo.InvariantCulture),
                initialDaylight ? "daylight" : "standard",
                initialDaylight ? zone.DaylightName : zone.StandardName);

            int fromYear = options.FromYear ?? 1800;
            DateTimeOffset start = new DateTimeOffset(fromYear, 1, 1, 0, 0, 0, TimeSpan.Zero);
            DateTimeOffset end = new DateTimeOffset(options.ToYear, 1, 1, 0, 0, 0, TimeSpan.Zero);

            DateTimeOffset? transition = GetNextTransition(zone, start.AddTicks(-1), end);
            while (transition != null)
            {
                var offset = zone.GetUtcOffset(transition.Value);
                var isDaylight = zone.IsDaylightSavingTime(transition.Value);
                // It's unfortunate that TimeZoneInfo doesn't support the idea of different names
                // for different periods in history. Never mind - this is better than nothing,
                // for diagnostic purposes.
                writer.Write("{0} {1} {2} {3}\n",
                    transition.Value.ToString("yyyy-MM-dd HH:mm:ss'Z'", CultureInfo.InvariantCulture),
                    (offset.Ticks >= 0 ? "+" : "-") + offset.ToString("hh':'mm':'ss", CultureInfo.InvariantCulture),
                    isDaylight ? "daylight" : "standard",
                    isDaylight ? zone.DaylightName : zone.StandardName);
                transition = GetNextTransition(zone, transition.Value, end);
            }
            writer.Write("\n");
        }
示例#11
0
        public void TimeAddNanoseconds()
        {
            DateTimeOffset offset = stored.AddTicks(-1);

#if !EFOLD
            var q = this.Entities
                    .Where(x =>
                           DbFunctions.AddNanoseconds(x.Offset, -100) == offset);
#else
            var q = this.Entities
                    .Where(x =>
                           EntityFunctions.AddNanoseconds(x.Offset, -100) == offset);
#endif

            q.Should().NotBeEmpty();
        }
示例#12
0
        internal static DateTimeOffset AdjustPrecision(DateTimeOffset value, byte precision)
        {
            if (precision > 6)
            {
                return(value);
            }

            var delta = value.Ticks % 10000000;

            switch (precision)
            {
            case 1: delta %= 1000000; break;

            case 2: delta %= 100000; break;

            case 3: delta %= 10000; break;

            case 4: delta %= 1000; break;

            case 5: delta %= 100; break;

            case 6: delta %= 10; break;
            }

            return(delta != 0 ? value.AddTicks(-delta) : value);
        }
        /// <summary>
        /// Parse the given string representation into a <see cref="DateTimeOffset"/> value.
        /// </summary>
        /// <param name="value">A string representation of a date time.</param>
        /// <returns>A <see cref="DateTimeOffset"/> value.</returns>
        public DateTimeOffset ParseDateTimeOffset(string value)
        {
            int          year, month, day, hour, minute, second, offsetHours, offsetMinutes;
            long         ticks;
            DateTimeKind dateTimeKind;

            GetDateTimeComponents(value, out year, out month, out day, out hour, out minute, out second, out ticks, out offsetHours, out offsetMinutes, out dateTimeKind);

            TimeSpan utcOffset;

            switch (dateTimeKind)
            {
            case DateTimeKind.Unspecified:
                utcOffset = TimeZone.CurrentTimeZone.GetUtcOffset(DateTime.Now);
                break;

            case DateTimeKind.Utc:
            case DateTimeKind.Local:
                utcOffset = new TimeSpan(offsetHours, offsetMinutes, 0);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }


            var dateTimeOffset = new DateTimeOffset(year, month, day, hour, minute, second, utcOffset);

            dateTimeOffset = dateTimeOffset.AddTicks(ticks);

            return(dateTimeOffset);
        }
示例#14
0
    public static CappedLogMessage ToLogMessage(this string message, DateTimeOffset now)
    {
        var diff = now.Ticks % TimeSpan.TicksPerMillisecond;
        var off  = Interlocked.Increment(ref _prevTime) % TimeSpan.TicksPerMillisecond;

        return(new CappedLogMessage(now.AddTicks(off - diff), message));
    }
        public void GivenAPartialDateTimeWithMissingComponents_WhenToDateTimeOffsetIsCalled_ThenCorrectDateTimeOffsetIsReturned()
        {
            const int     expectedMonth     = 2;
            const int     expectedDay       = 10;
            const int     expectedHour      = 15;
            const int     expectedMinute    = 13;
            const int     expectedSecond    = 12;
            const decimal expectedFraction  = 0.3009953m;
            var           expectedUtcOffset = TimeSpan.FromMinutes(30);

            var dateTime = PartialDateTime.Parse("2013");

            var actualOffset = dateTime.ToDateTimeOffset(
                expectedMonth,
                (year, month) => expectedDay,
                expectedHour,
                expectedMinute,
                expectedSecond,
                expectedFraction,
                expectedUtcOffset);

            var expectedOffset = new DateTimeOffset(
                2013,
                expectedMonth,
                expectedDay,
                expectedHour,
                expectedMinute,
                expectedSecond,
                expectedUtcOffset);

            expectedOffset = expectedOffset.AddTicks((long)(expectedFraction * TimeSpan.TicksPerSecond));

            Assert.Equal(expectedOffset, actualOffset);
        }
        public void GivenAPartialDateTimeWithNoMissingComponent_WhenToDateTimeOffsetIsCalled_ThenCorrectDateTimeOffsetIsReturned()
        {
            var dateTime = PartialDateTime.Parse("2013-10-12T23:01:35.9995555+02:00");

            var actualOffset = dateTime.ToDateTimeOffset(
                2,
                (year, month) => 10,
                15,
                13,
                12,
                0.300250m,
                TimeSpan.FromMinutes(30));

            var expectedOffset = new DateTimeOffset(
                2013,
                10,
                12,
                23,
                01,
                35,
                TimeSpan.FromMinutes(120));

            expectedOffset = expectedOffset.AddTicks((long)(0.9995555m * TimeSpan.TicksPerSecond));

            Assert.Equal(expectedOffset, actualOffset);
        }
        public async Task LowerDigitsAreIgnoredAsync()
        {
            if (!Dialect.SupportsDateTimeScale)
            {
                Assert.Ignore("Lower digits cannot be ignored when dialect does not support scale");
            }

            var baseDate = new DateTimeOffset(2017, 10, 01, 17, 55, 24, 548, TimeSpan.FromHours(2));
            var entity   = new DateTimeOffsetClass
            {
                Id    = AdditionalDateId,
                Value = baseDate.AddTicks(TimeSpan.TicksPerMillisecond / 3)
            };

            Assert.That(entity.Value, Is.Not.EqualTo(baseDate));

            using (var s = OpenSession())
                using (var t = s.BeginTransaction())
                {
                    await(s.SaveAsync(entity));
                    await(t.CommitAsync());
                }

            using (var s = OpenSession())
                using (var t = s.BeginTransaction())
                {
                    var retrieved = await(s.LoadAsync <DateTimeOffsetClass>(AdditionalDateId));
                    Assert.That(retrieved.Value, Is.EqualTo(baseDate));
                    await(t.CommitAsync());
                }
        }
        public void GivenAPartialDateTimeWithNoMissingComponent_WhenToDateTimeOffsetIsCalled_ThenCorrectDateTimeOffsetIsReturned()
        {
            PartialDateTime dateTime = _builder.ToPartialDateTime();

            DateTimeOffset actualOffset = dateTime.ToDateTimeOffset(
                2,
                (year, month) => 10,
                15,
                13,
                12,
                0.300250m,
                TimeSpan.FromMinutes(30));

            DateTimeOffset expectedOffset = new DateTimeOffset(
                DefaultYear,
                DefaultMonth,
                DefaultDay,
                DefaultHour,
                DefaultMinute,
                DefaultSecond,
                DefaultUtcOffset);

            expectedOffset = expectedOffset.AddTicks((long)(DefaultFraction * TimeSpan.TicksPerSecond));

            Assert.Equal(expectedOffset, actualOffset);
        }
示例#19
0
        // --------------------------------------------------------------------------------

        public static DateTimeOffset Ceiling(this DateTimeOffset dto, DateTimeFieldEnum field)
        {
            switch (field)
            {
            case DateTimeFieldEnum.MILLISEC: {
                dto = dto.AddTicks(9999);
                return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, dto.Millisecond, dto.Offset));
            }

            case DateTimeFieldEnum.SECOND: {
                dto = dto.AddMilliseconds(999);
                return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, dto.Second, 0, dto.Offset));
            }

            case DateTimeFieldEnum.MINUTE: {
                dto = dto.AddSeconds(59);
                return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, dto.Minute, 0, 0, dto.Offset));
            }

            case DateTimeFieldEnum.HOUR: {
                dto = dto.AddMinutes(59);
                return(new DateTimeOffset(dto.Year, dto.Month, dto.Day, dto.Hour, 0, 0, 0, dto.Offset));
            }

            case DateTimeFieldEnum.DAY:
            case DateTimeFieldEnum.DATE: {
                var baseDto = new DateTimeOffset(dto.Year, dto.Month, dto.Day, 0, 0, 0, 0, dto.Offset);
                if (baseDto == dto)
                {
                    return(baseDto);
                }

                return(baseDto.AddDays(1));
            }

            case DateTimeFieldEnum.MONTH: {
                var baseDto = new DateTimeOffset(dto.Year, dto.Month, 1, 0, 0, 0, 0, dto.Offset);
                if (baseDto == dto)
                {
                    return(baseDto);
                }

                return(baseDto.AddMonths(1));
            }

            case DateTimeFieldEnum.YEAR: {
                var baseDto = new DateTimeOffset(dto.Year, 1, 1, 0, 0, 0, 0, dto.Offset);
                if (baseDto == dto)
                {
                    return(baseDto);
                }

                return(baseDto.AddYears(1));
            }

            default:
                throw new NotSupportedException();
            }
        }
        private static DateTimeOffset CeilingCore(DateTimeOffset dateTime, [NonNegativeValue] long ticksModule)
        {
            Code.InRange(ticksModule, nameof(ticksModule), 1, long.MaxValue);

            var overflow = dateTime.Ticks % ticksModule;

            return(overflow == 0 ? dateTime : dateTime.AddTicks(ticksModule - overflow));
        }
 public static DateTimeOffset Truncate(this DateTimeOffset dateTime, TimeSpan timeSpan)
 {
     if (timeSpan == TimeSpan.Zero)
     {
         return(dateTime);
     }
     return(dateTime.AddTicks(-(dateTime.Ticks % timeSpan.Ticks)));
 }
        private static DateTimeOffset FloorCore(DateTimeOffset dateTime, long ticksModule)
        {
            Code.InRange(ticksModule, nameof(ticksModule), 1, long.MaxValue);

            var overflow = dateTime.Ticks % ticksModule;

            return(dateTime.AddTicks(-overflow));
        }
示例#23
0
        /// <summary>
        /// Round this <see cref="DateTimeOffset"/> to the specified <see cref="TimeSpan"/> precision.
        /// </summary>
        /// <param name="DateTimeOffset"></param>
        /// <param name="precision"></param>
        /// <returns></returns>
        public static DateTimeOffset Round(this DateTimeOffset DateTimeOffset, TimeSpan precision)
        {
            var delta         = DateTimeOffset.Ticks % precision.Ticks;
            var shouldRoundUp = delta > (precision.Ticks / 2L);
            var offset        = shouldRoundUp ? precision.Ticks : 0L;

            return(DateTimeOffset.AddTicks(offset - delta));
        }
示例#24
0
        public static bool WithinSkew(DateTimeOffset now, DateTimeOffset ctime, int usec, TimeSpan skew)
        {
            ctime = ctime.AddTicks(usec / 10);

            var skewed = TimeSpan.FromMilliseconds(Math.Abs((now - ctime).TotalMilliseconds));

            return(skewed <= skew);
        }
示例#25
0
 public static DateTimeOffset Timestamp(long elapsedTicks)
 {
     // Stopwatch ticks are different from DateTime.Ticks.
     // Each tick in the DateTime.Ticks value represents one 100-nanosecond interval.
     // Each tick in the ElapsedTicks value represents the time interval equal to
     // 1 second divided by the Frequency.
     return(StartTime.AddTicks(Convert.ToInt64(elapsedTicks * HundredNanosecondsPerTick)));
 }
示例#26
0
        public DateTimeOffset DurationForPlayer(string playerId, IList <POPpicGameMove> gameMoves)
        {
            DateTimeOffset duration = DateTimeOffset.MinValue;
            var            ticks    = gameMoves.Where((POPpicGameMove m) => m.UserId == playerId).Sum((POPpicGameMove m) => m.MoveDuration.Ticks);

            duration.AddTicks(ticks);
            return(duration);
        }
示例#27
0
 public static DateTimeOffset Truncate(this DateTimeOffset dateTime, TimeSpan timeSpanTruncation)
 {
     if (dateTime == DateTimeOffset.MinValue || dateTime == DateTimeOffset.MaxValue)
     {
         return(dateTime); // do not modify guard values
     }
     return(dateTime.AddTicks(-(dateTime.Ticks % timeSpanTruncation.Ticks)));
 }
示例#28
0
 /// <summary>
 /// Fakes the current time to the time specified, making slight increments in time for each invocation
 /// (the slight increments can be turned off by setting <paramref name="incrementSlightlyOnEachInvocation"/> to false)
 /// </summary>
 public static void FakeIt(DateTimeOffset fakeTime, bool incrementSlightlyOnEachInvocation = true)
 {
     RebusTime.CurrentTimeFactory = () =>
     {
         var timeToReturn = fakeTime;
         fakeTime = fakeTime.AddTicks(1);
         return timeToReturn;
     };
 }
        private static DateTimeOffset RoundAwayFromZeroCore(DateTimeOffset dateTime, [NonNegativeValue] long ticksModule)
        {
            Code.InRange(ticksModule, nameof(ticksModule), 1, long.MaxValue);

            var halfIntervalTicks    = (ticksModule + 1) >> 1;
            var halfIntervalOverflow = (dateTime.Ticks + halfIntervalTicks) % ticksModule;

            return(dateTime.AddTicks(halfIntervalTicks - halfIntervalOverflow));
        }
示例#30
0
        private static DateTimeOffset Truncate(DateTimeOffset dateTime)
        {
            if (dateTime == DateTimeOffset.MinValue || dateTime == DateTimeOffset.MaxValue)
            {
                return(dateTime);
            }

            return(dateTime.AddTicks(-(dateTime.Ticks % TimeSpan.FromSeconds(1).Ticks)));
        }
        public static DateTimeOffset EndOfDay(this DateTimeOffset date)
        {
            var endOfDay = new DateTimeOffset(date.Year, date.Month, date.Day, 0, 0, 0, date.Offset);

            endOfDay = endOfDay.AddDays(1);
            endOfDay = endOfDay.AddTicks(-1);

            return(endOfDay);
        }
        public void CorrectConversionTest(DateTimeOffset date, string timezone)
        {
            // Truncate milliseconds since we don't use them for the UNIX timestamps.
            var dateTimeOffset = date.AddTicks(-(date.Ticks % TimeSpan.TicksPerSecond));

            var convertedDate = dateTimeOffset.ToUnixTimeSeconds().ToDateTimeOffsetFromUnixTimestamp(timezone);

            Assert.Equal(dateTimeOffset, convertedDate);
        }
示例#33
0
        public static DateTimeOffset SubtractTicks(this DateTimeOffset date, long value)
        {
            if (value < 0)
            {
                throw new ArgumentException("Value cannot be less than 0.", "value");
            }

            return(date.AddTicks(value * -1));
        }
 public override object ConvertToStorageType(object value) {
     if (value != null) {
         var dateTime = new DateTimeOffset(new DateTime(1753, 1, 1));
         if (dateTime > (DateTimeOffset)value) {
             var time = ((DateTimeOffset)value).TimeOfDay;
             DateTimeOffset storageType = dateTime.AddTicks(time.Ticks);
             return storageType.DateTime;
         }
         dateTime = new DateTimeOffset(new DateTime(9999, 12, 31));
         return dateTime < (DateTimeOffset)value ? dateTime.DateTime : ((DateTimeOffset)value).DateTime;
     }
     return null;
 }
    public void From_FromFixedDateTime_Tests(int value)
    {
        var originalPointInTime = new DateTimeOffset(1976, 12, 31, 17, 0, 0, 0, TimeSpan.Zero);

        Assert.AreEqual(value.Years().From(originalPointInTime), originalPointInTime.AddYears(value));
        Assert.AreEqual(value.Months().From(originalPointInTime), originalPointInTime.AddMonths(value));
        Assert.AreEqual(value.Weeks().From(originalPointInTime), originalPointInTime.AddDays(value*DaysPerWeek));
        Assert.AreEqual(value.Days().From(originalPointInTime), originalPointInTime.AddDays(value));

        Assert.AreEqual(value.Hours().From(originalPointInTime), originalPointInTime.AddHours(value));
        Assert.AreEqual(value.Minutes().From(originalPointInTime), originalPointInTime.AddMinutes(value));
        Assert.AreEqual(value.Seconds().From(originalPointInTime), originalPointInTime.AddSeconds(value));
        Assert.AreEqual(value.Milliseconds().From(originalPointInTime), originalPointInTime.AddMilliseconds(value));
        Assert.AreEqual(value.Ticks().From(originalPointInTime), originalPointInTime.AddTicks(value));
    }
        /// <summary>
        /// Parse the given string representation into a <see cref="DateTimeOffset"/> value.
        /// </summary>
        /// <param name="value">A string representation of a date time.</param>
        /// <returns>A <see cref="DateTimeOffset"/> value.</returns>
        public DateTimeOffset ParseDateTimeOffset(string value)
        {
            int year, month, day, hour, minute, second, offsetHours, offsetMinutes;
            long ticks;
            DateTimeKind dateTimeKind;

            GetDateTimeComponents(value, out year, out month, out day, out hour, out minute, out second, out ticks, out offsetHours, out offsetMinutes, out dateTimeKind);

            var offset = new TimeSpan(offsetHours, offsetMinutes, 0);
            var dateTimeOffset = new DateTimeOffset(year, month, day, hour, minute, second, offset);
            dateTimeOffset = dateTimeOffset.AddTicks(ticks);

            return dateTimeOffset;
        }
示例#37
0
        //// BUTTONCLICK HANDLERS ///////////////////////////////////////////////

        public DialogResult OKButton_Click(object sender, EventArgs e)
        {
            DialogResult dr = DialogResult.Cancel;
            if (ap.modified)
            {
                INCCDB.AcquireSelector sel = new INCCDB.AcquireSelector(det, ap.item_type, DateTime.Now);
                ap.MeasDateTime = sel.TimeStamp; ap.lm.TimeStamp = sel.TimeStamp;
                NC.App.DB.AcquireParametersMap().Add(sel, ap);  // it's a new one, not the existing one modified
                NC.App.DB.UpdateAcquireParams(ap, det.ListMode);
            }

            // The acquire is set to occur, build up the measurement state 
            AnalysisWizard.ResetMeasurement();
            Integ.BuildMeasurement(ap, det, mo);

            switch (ap.data_src)
            {
                case ConstructedSource.Live:             // set up the instrument list for the action controller
                    UIIntegration.Controller.file = false;  // make sure to use the DAQ controller, not the file controller
                    NC.App.AppContext.FileInput = null;  // reset the cmd line file input flag
                    if (det.ListMode)
                    {
                        // patch override lm.Interval with run_count_time from dialog
                        NC.App.Opstate.Measurement.AcquireState.lm.Interval = NC.App.Opstate.Measurement.AcquireState.run_count_time;

                        // Check NC.App.Opstate.Measurement.AnalysisParams for at least one VSR 
                        // If not present, inform and pop up the wizard
                        // If present, inform with new dialog, do not pop up the wizard
                        if (NC.App.Opstate.Measurement.AnalysisParams.HasMultiplicity())
                        {
                            dr = DialogResult.OK;
                        }
                        else
                        {
                            AnalysisWizard awl = new AnalysisWizard(AnalysisWizard.AWSteps.Step2B, ap, det);  // analyzers are created in here, placed on global measurement
                            dr = awl.ShowDialog();
                            if (dr == DialogResult.OK)
                            {
                                NC.App.DB.UpdateAcquireParams(ap); //update it again
                                NC.App.DB.UpdateDetector(det);
                            }
                        }

                        if (dr == DialogResult.OK)
                        {
                            // if ok, the analyzers are set up, so can kick it off now.
                            UIIntegration.Controller.ActivateDetector(det); 
                        }
                    }
                    else
                    {
                        SRInstrument sri = new SRInstrument(det);
                        sri.selected = true;
                        sri.Init(NC.App.Loggers.Logger(LMLoggers.AppSection.Data), NC.App.Loggers.Logger(LMLoggers.AppSection.Analysis));
                        if (!Instruments.All.Contains(sri))
                            Instruments.All.Add(sri); // add to global runtime list 
                        dr = DialogResult.OK;
                    }
                    break;
                case ConstructedSource.DB:
                    NC.App.AppContext.DBDataAssay = true;
                    UIIntegration.Controller.file = true;
                    IDDAcquireDBMeas dbdlg = new IDDAcquireDBMeas(this);
                    if (dbdlg.HasItems())
                    {
                        dr = dbdlg.ShowDialog();
                        if (dr == DialogResult.OK)
                        {
                            DateTimeOffset dto = dbdlg.measurementId.MeasDateTime;
                            DateTimeOffset cur = new DateTimeOffset(dto.Ticks, dto.Offset);
                            NC.App.Logger(NCCReporter.LMLoggers.AppSection.App).TraceEvent(NCCReporter.LogLevels.Info, 87654,
                                    "Using " + dto.ToString("MMM dd yyy HH:mm:ss.ff K"));

                            // get the cycles for the selected measurement from the database, and add them to the current measurement
                            CycleList cl = NC.App.DB.GetCycles(det, dbdlg.measurementId);
                            foreach(Cycle cycle in cl)  // add the necessary meta-data to the cycle identifier instance
                            {
                                cycle.UpdateDataSourceId(ap.data_src, det.Id.SRType, 
                                                    cur.AddTicks(cycle.TS.Ticks), det.Id.FileName);
                                cur = cycle.DataSourceId.dt;
                            }

                            NC.App.Opstate.Measurement.Add(cl);

                            // TODO: for Reanalysis, a full reconstruction of the measurement state based on the ResultsRec state and the method parameter map contents (for Calib and Verif)
                        }
                    }
                    else
                        MessageBox.Show("No items found in database matching these parameters", "WARNING");
                    break;
                case ConstructedSource.Manual:
                    UIIntegration.Controller.file = true;
                    NC.App.AppContext.DBDataAssay = true;
                    IDDManualDataEntry mdlg = new IDDManualDataEntry();
                    mdlg.AH = this;
                    dr = mdlg.ShowDialog();
                    if (dr == DialogResult.OK)
                    {
                        // the work is done in the dialog class
                    }
                    break;

                case ConstructedSource.CycleFile:
                    NC.App.AppContext.TestDataFileAssay = true;
                    UIIntegration.Controller.file = true;
                    dr = UIIntegration.GetUsersFile("Select a test data (disk) file", NC.App.AppContext.FileInput, "INCC5 Test data (disk)", "dat");
                    break;
                case ConstructedSource.ReviewFile:
                    NC.App.AppContext.ReviewFileAssay = true;
                    UIIntegration.Controller.file = true;
                    dr = UIIntegration.GetUsersFile("Select an NCC file", NC.App.AppContext.FileInput, "INCC5 Review", "NCC");
                    break;
                case ConstructedSource.NCDFile:
                    NC.App.AppContext.NCDFileAssay = true;
                    UIIntegration.Controller.file = true;
                    if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified)
                    {
                        AnalysisWizard aw = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det);
                        dr = aw.ShowDialog(); // show LM-relevant acquire-style settings for modification or confirmation
                    }
                    else
                    {
                        dr = UIIntegration.GetUsersFilesFolder("Select NCD files or folder", NC.App.AppContext.FileInput, "LMMM NCD", "ncd");
                    }
                    break;
                case ConstructedSource.SortedPulseTextFile:
                    NC.App.AppContext.PulseFileAssay = true;
                    UIIntegration.Controller.file = true;
                    if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified)
                    {
                        AnalysisWizard aw1 = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det);
                        dr = aw1.ShowDialog();  // show LM-relevant acquire-style settings for modification or confirmation
                    }
                    else
                    {
                        dr = UIIntegration.GetUsersFilesFolder("Select pulse files or folder", NC.App.AppContext.FileInput, "pulse", "txt");
                    }
                    break;
                case ConstructedSource.PTRFile: 
                    NC.App.AppContext.PTRFileAssay = true;
                    UIIntegration.Controller.file = true;
                    if (NC.App.Opstate.Measurement.MeasOption == AssaySelector.MeasurementOption.unspecified)
                    {
                        AnalysisWizard aw2 = new AnalysisWizard(AnalysisWizard.AWSteps.Step2A, ap, det);
                        dr = aw2.ShowDialog();  // show LM-relevant acquire-style settings for modification or confirmation
                    }
                    else
                    {
                        dr = UIIntegration.GetUsersFilesFolder("Select PTR-32 files or folder", NC.App.AppContext.FileInput, "PTR-32", "bin", "chn");
                    }
                    break;
                case ConstructedSource.NILAFile:
                    NC.App.AppContext.NILAFileAssay = true;
                    UIIntegration.Controller.file = true;
                    dr = UIIntegration.GetUsersFilesFolder("Select NILA files or folder", NC.App.AppContext.FileInput, "MTS NILA", "dat");
                    //dr = DialogResult.Cancel;
                    break;
                default:
                    break;
            }
            return dr;
        }
示例#38
0
        public void CanAddTicksAcrossDstTransition()
        {
            var tz = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
            var dto = new DateTimeOffset(2015, 3, 8, 1, 59, 59, 999, TimeSpan.FromHours(-8)).AddTicks(9999);
            var result = dto.AddTicks(1, tz);

            var expected = new DateTimeOffset(2015, 3, 8, 3, 0, 0, TimeSpan.FromHours(-7));
            Assert.Equal(expected, result);
            Assert.Equal(expected.Offset, result.Offset);
        }
示例#39
0
 public static void AddTicks(DateTimeOffset dateTimeOffset, long ticks, DateTimeOffset expected)
 {
     Assert.Equal(expected, dateTimeOffset.AddTicks(ticks));
 }
        /// <summary>
        /// Parse the given string representation into a <see cref="DateTimeOffset"/> value.
        /// </summary>
        /// <param name="value">A string representation of a date time.</param>
        /// <returns>A <see cref="DateTimeOffset"/> value.</returns>
        public DateTimeOffset ParseDateTimeOffset(string value)
        {
            int year, month, day, hour, minute, second, offsetHours, offsetMinutes;
            long ticks;
            DateTimeKind dateTimeKind;

            GetDateTimeComponents(value, out year, out month, out day, out hour, out minute, out second, out ticks, out offsetHours, out offsetMinutes, out dateTimeKind);

            TimeSpan utcOffset;

            switch (dateTimeKind)
            {
                case DateTimeKind.Unspecified:
                    utcOffset = TimeZone.CurrentTimeZone.GetUtcOffset(DateTime.Now);
                    break;
                case DateTimeKind.Utc:
                case DateTimeKind.Local:
                    utcOffset = new TimeSpan(offsetHours, offsetMinutes, 0);
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }

            var dateTimeOffset = new DateTimeOffset(year, month, day, hour, minute, second, utcOffset);
            dateTimeOffset = dateTimeOffset.AddTicks(ticks);

            return dateTimeOffset;
        }
示例#41
0
        //[Variation("ToString(DateTimeOffset, format) - valid cases")]
        public int ToType57()
        {
            var dto = new DateTimeOffset();
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM"), "0001-01", "datetimeOffset1");

            dto = new DateTimeOffset();
            CError.Equals(XmlConvert.ToString(dto, "yyyy"), "0001", "datetimeOffset2");

            dto = new DateTimeOffset();
            CError.Equals(XmlConvert.ToString(dto, null), "01/01/0001 00:00:00 +00:00", "datetimeOffset3");

            string s = XmlConvert.ToString(XmlConvert.ToDateTimeOffset("2002-12-30"), "yyyy-MM-dd");
            CError.Equals(s, "2002-12-30", "datetimeOffset");

            dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero);
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "2002-12-30T23:15:55+00:00", "datetimeOffset4");

            dto = new DateTimeOffset(1, 1, 1, 23, 59, 59, TimeSpan.Zero);
            dto = dto.AddTicks(9999999);
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "0001-01-01T23:59:59+00:00", "datetimeOffset5");

            dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero);
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "2002-12-30T23:15:55+00:00", "datetimeOffset6");

            dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero);
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-dd"), "2002-12-30", "datetimeOffset7");

            dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero);
            CError.Equals(XmlConvert.ToString(dto, "HH:mm:ss"), "23:15:55", "datetimeOffset8");

            dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero);
            CError.Equals(XmlConvert.ToString(dto, "HH:mm:ssZ"), "23:15:55Z", "datetimeOffset9");

            dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, TimeSpan.FromMinutes(0));
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "0001-01-01T00:00:00+00:00", "datetimeOffset10");

            dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, TimeSpan.FromMinutes(-840));
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "0001-01-01T00:00:00-14:00", "datetimeOffset11");

            dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, TimeSpan.FromMinutes(840));
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "9999-12-31T23:59:59+14:00", "datetimeOffset12");

            dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, TimeSpan.FromMinutes(840));
            CError.Equals(XmlConvert.ToString(dto, null), "12/31/9999 23:59:59 +14:00", "datetimeOffset13");

            dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, TimeSpan.FromMinutes(0));
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "9999-12-31T23:59:59+00:00", "datetimeOffset14");

            dto = DateTimeOffset.MaxValue;
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "9999-12-31T23:59:59+00:00", "datetimeOffset16");

            dto = DateTimeOffset.MaxValue;
            CError.Equals(XmlConvert.ToString(dto, null), "12/31/9999 23:59:59 +00:00", "datetimeOffset18");

            dto = DateTimeOffset.MinValue;
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:sszzzzzz"), "0001-01-01T00:00:00+00:00", "datetimeOffset19");

            dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, 1, TimeSpan.FromHours(-0));
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "0001-01-01T00:00:00.001+00:00", "datetimeOffset22");

            dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, 999, TimeSpan.FromHours(14));
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "9999-12-31T23:59:59.999+14:00", "datetimeOffset23");

            dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, 999, TimeSpan.FromHours(-14));
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "0001-01-01T00:00:00.999-14:00", "datetimeOffset24");

            dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, 125, TimeSpan.FromHours(14));
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "9999-12-31T23:59:59.125+14:00", "datetimeOffset25");

            dto = new DateTimeOffset(2000, 2, 29, 23, 59, 59, 999, TimeSpan.FromHours(-14));
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "2000-02-29T23:59:59.999-14:00", "datetimeOffset26");

            dto = new DateTimeOffset(2000, 2, 29, 23, 59, 59, 444, TimeSpan.FromHours(+14));
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "2000-02-29T23:59:59.444+14:00", "datetimeOffset27");

            dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, 999, TimeSpan.FromHours(14));
            CError.Equals(XmlConvert.ToString(dto, "yyyy-MM-ddTHH:mm:ss.FFFFFFFzzzzzz"), "9999-12-31T23:59:59.999+14:00", "datetimeOffset28");
            return TEST_PASS;
        }
示例#42
0
        //[Variation("ToString(DateTimeOffset) - valid cases")]
        public int ToType56()
        {
            var dto = new DateTimeOffset();
            CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00Z", "datetimeOffset1");

            dto = new DateTimeOffset(2002, 12, 30, 0, 0, 0, 0, TimeSpan.FromHours(-8));
            CError.Equals(XmlConvert.ToString(dto), "2002-12-30T00:00:00-08:00", "datetimeOffset2");

            dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, 556, TimeSpan.Zero);
            CError.Equals(XmlConvert.ToString(dto), "2002-12-30T23:15:55.556Z", "datetimeOffset3");

            dto = new DateTimeOffset(1, 1, 1, 23, 59, 59, TimeSpan.Zero);
            dto = dto.AddTicks(9999999);
            CError.Equals(XmlConvert.ToString(dto), "0001-01-01T23:59:59.9999999Z", "milisecs");

            dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero);
            CError.Equals(XmlConvert.ToString(dto), "2002-12-30T23:15:55Z", "datetimeOffset4");

            dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, TimeSpan.FromHours(0));
            CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00Z", "datetimeOffset5");

            dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, TimeSpan.FromHours(-14));
            CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00-14:00", "datetimeOffset6");

            dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, TimeSpan.FromHours(14));
            CError.Equals(XmlConvert.ToString(dto), "9999-12-31T23:59:59+14:00", "datetimeOffset7");

            dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, TimeSpan.FromHours(0));
            CError.Equals(XmlConvert.ToString(dto), "9999-12-31T23:59:59Z", "datetimeOffset8");

            dto = DateTimeOffset.MaxValue;
            CError.Equals(XmlConvert.ToString(dto), "9999-12-31T23:59:59.9999999Z", "datetimeOffset10");

            dto = DateTimeOffset.MinValue;
            CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00Z", "datetimeOffset11");

            dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, 1, TimeSpan.FromHours(-0));
            CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00.001Z", "datetimeOffset14");

            dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, 999, TimeSpan.FromHours(14));
            CError.Equals(XmlConvert.ToString(dto), "9999-12-31T23:59:59.999+14:00", "datetimeOffset15");

            dto = new DateTimeOffset(1, 1, 1, 0, 0, 0, 999, TimeSpan.FromHours(-14));
            CError.Equals(XmlConvert.ToString(dto), "0001-01-01T00:00:00.999-14:00", "datetimeOffset16");

            dto = new DateTimeOffset(9999, 12, 31, 23, 59, 59, 125, TimeSpan.FromHours(14));
            CError.Equals(XmlConvert.ToString(dto), "9999-12-31T23:59:59.125+14:00", "datetimeOffset17");

            dto = new DateTimeOffset(2000, 2, 29, 23, 59, 59, 999, TimeSpan.FromHours(-14));
            CError.Equals(XmlConvert.ToString(dto), "2000-02-29T23:59:59.999-14:00", "datetimeOffset18");

            dto = new DateTimeOffset(2000, 2, 29, 23, 59, 59, 444, TimeSpan.FromHours(+14));
            CError.Equals(XmlConvert.ToString(dto), "2000-02-29T23:59:59.444+14:00", "datetimeOffset19");

            dto = new DateTimeOffset(2000, 2, 29, 23, 59, 59, 999, TimeSpan.FromHours(-14));
            CError.Equals(XmlConvert.ToString(dto), "2000-02-29T23:59:59.999-14:00", "datetimeOffset20");
            return TEST_PASS;
        }
示例#43
0
        public void DATETIMEOFFSET_Data_ScriptsCorrectly()
        {
            DateTimeOffset baseData = new DateTimeOffset(2000, 10, 31, 2, 33, 44, new TimeSpan(3,0,0));
            object data = baseData;
            var fieldInfo = SchemaScriptingTests.FakeColumn("test", "test", 32, "datetimeoffset", false, 0, 0);
            Assert.AreEqual("'2000-10-31T02:33:44+03:00'", FieldScripting.valueAsTSQLLiteral(data, fieldInfo), "datetimeoffset no fractional seconds");
            Assert.AreEqual("2000-10-31T02:33:44+03:00", FieldScripting.formatDatetimeoffset(data, false), "datetimeoffset no fractional seconds");

            baseData = baseData.AddTicks(1234567);
            data = baseData;
            Assert.AreEqual("'2000-10-31T02:33:44.1234567+03:00'", FieldScripting.valueAsTSQLLiteral(data, fieldInfo), "datetimeoffset fractional seconds");
            Assert.AreEqual("2000-10-31T02:33:44.1234567+03:00", FieldScripting.formatDatetimeoffset(data, false), "datetimeoffset fractional seconds");
        }